problème erreur a la compilation

**joe0703** · 23/11/2017, 14h19

bonjour,
je vous écrit ce message car je bloque un peu sur une erreur.
pour la fac j ai un tp de backtracking a faire
le sujet etant

I. Présentation
Cinq maisons de couleurs différentes sont habitées par des hommes de nationalités diverses, ayant
chacun un animal favori, une boisson préférée et une marque de cigarettes. Ces cinq maisons
respectent les contraintes suivantes :
– L'Anglais habite la maison rouge.
– Le chien appartient à l'Espagnol.
– On boit du café dans la maison verte.
– L'Ukrainien boit du thé.
– La maison verte est à côté de la blanche, à droite.
– Le fumeur de Old Gold élève des escargots.
– On fume des Kool dans la maison jaune.
– On boit du lait dans la maison du milieu.
– Le Norvégien habite la première maison à gauche.
– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
– Le fumeur de Kool habite à côté du propriétaire du cheval.
– Le fumeur de gitanes boit du vin.
– Le Japonais fume des Craven.
– Le Norvégien habite à côté de la maison bleue.

II. Objectifs

Répondre aux questions :
Qui boit de l'eau ?
A qui appartient le zèbre ?

III. Structure de données

Pour ce problème des structures légères suffiront : une matrice 5x5 (d'entiers ou de caractères par
exemple) contiendra les 5 caractéristiques des 5 maisons.
Dans une première version les contraintes à respecter pourront être codées "en dur" dans la fonction
acceptable.
Dans une deuxième version vous proposerez une structure de données plus générales pour
représenter les contraintes.

IV. Au final

La solution sera donc un tableau rempli respectant toutes les contraintes. Le programme se terminera
en répondant aux deux questions.
Vous rendrez les sources de votre programme accompagné d'un fichier d'explications sous forme
d'une archive tar.

a l'heur actuel j ai fait ceci

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
#include <iostream>
 
using namespace std;
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de separer les block de maniere vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien abscente d une colonne
 
bool AbsentSurColonne ( string k, string grille[5][5],int j)
{
    for ( int i=0; i<5; i++)
    {
        if ( grille[i][j]==k)//si la valeur est deja presente sur la colonne
            return false;
        return true;
    }
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entree et la reseoudre
 
//nous devons constamment verifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va doonc utiliser le retour de la fonction pour nous indiquer si la grille est valide ou non
//enfin , comme notre fonction doit etre recursive, nous allonns ajouter un parametre pour savoir quelle case nous somme en train de trater
 
//une case (i,j) dans un tableau peut etre representer par un nombre (i*largeur_tableau)+j, que nous nommerons position
 
bool valide( string maison[5][5], int i ,int a )
{
 
//sur une même ligne: les valeurs doivent être différentes
  for(int k=0;k<i;k++)
   {
        if(maison[i][a]==maison[k][a])
            return false;
   }
 
    //On boit du lait dans la maison du milieu.
    if(  maison[2][3]!="lait")
        return false ;
 
	//– L'Anglais habite la maison rouge
	if( !((maison[i][1]="anglais") && (maison[i][0]="rouge") ))
        return false ;
 
	//– Le chien appartient à l'Espagnol.
	if( !((maison[i][1]="espagnol") && (maison[i][4]="chien")) )
        return false ;
 
	//– On boit du café dans la maison verte.
	if( !((maison[i][2]="cafe") && (maison[i][0]="verte")) )
        return false  ;
 
	//– L'Ukrainien boit du thé.
	if( !((maison[i][1]="ukrainien") && (maison[i][2]="the")) )
        return false;
 
	//– La maison verte est à côté de la blanche, à droite.
	if( !((maison[i][0]="blanche") && (maison[i+1][0]="verte")) )
        return false ;
 
	//– Le fumeur de Old Gold élève des escargots.
	if( !((maison[i][4]="escargots") && (maison[i][3]="old")) )
        return false;
 
	//– On fume des Kool dans la maison jaune.
	if( !((maison[i][3]="kool") && (maison[i][0]="jaune") ))
        return false ;
 
	//– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
	if( !((maison[i][3]="chesterfield") && (maison[i+1][4]="renard" || maison[i-1][4])="renard" )))
        return false;
 
	//– Le fumeur de Kool habite à côté du propriétaire du cheval.
	if( !((maison[i][3]="kool") && ( maison[i+1][4]="chevale" || maison[i-1][4]="cheval") ))
        return false;
 
	//– Le fumeur de gitanes boit du vin.
	if( !((maison[i][2]="vin") && (maison[i][3]="gitane" )))
        return false ;
 
	//– Le Japonais fume des Craven.
	if( !((maison[i][3]="craven") && (maison[i][1]="japonais" ) ))
        return false;
 
	//– Le Norvégien habite à côté de la maison bleue. et le norvegien habite la premiere maison a gauche
	if( !((maison[0][1]="norvegien") && (maison[1][0]="bleu")) )
        return false ;
 
	else
        return true;
 
}
 
bool estValide (string grille[5][5], int position, string tableau[5),tableau [5])
{
    // si on est a la 25eme case ( on sort du tableau)
    if(position == 5*5)
        return true;
 
    //on recupere les coordonnees de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel recursif)
    if (grille[i][j] !="0")
        return estValide(grille, position +1, tableau[5]);
 
    //enumeration des valeurs possible
    for(int k = 0; k<5 ; k++)
    {
        //si la valeur est abscente ,et si elle repond au contrainte
        if(AbsentSurColonne(tableau[k],grille,i)&& valide )
        {
            //on enregistre dans la grille
            grille[i][j];
            // on appelle recursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( est valide (grille, position+1,tableau[5]))
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
    //toutes les valeur ont ete testes, aucun n'est bon , on reinitialise la case
    grille[i][j] = "0";
    //puis on retourn faux
    return false;
}
 
int main ()
{
    //avant tout, on donner les variable possible grace a des tableau
    string couleur [5] = {rouge,verte,jaune,bleu,blanche}
    string nationalite [5] = {anglais,espagnol,norvegien,japonais,ukrainien}
    string boisson [5]= {eau,the,cafe,vin,lait}
    string cigarette [5]= {craven,old,kool,chesterfiel,gitane}
    string animaux [5]= {zebre,renard,chien,cheval,escargots}
   //  nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on cree un tableau en deux dimension
    //les grille vides etant representer par des 0
    int grille[5][5] =
    {
        {0,0,0,0,0},// couleur
        {0,0,0,0,0},//nationalite
        {0,0,0,0,0},//boisson
        {0,0,0,0,0},//cigarette
        {0,0,0,0,0}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,couleur);
    estValide(grille,0,nationalite);
    estValide(grille,0,boisson);
    estValide(grille,0,cigarette);
    estValide(grille,0,animaux);
    cout<<"grille apres"<<endl;
    affichage(grille);
}

mon soucis étant que quand je lance la compilation j'obtient

|

error: no match for 'operator!' (operand type is 'std::basic_string<char>')|

error: no match for 'operator&&' (operand types are 'std::basic_string<char>' and 'std::basic_string<char>')|

error: no match for 'operator||' (operand types are 'const char [7]' and 'std::string {aka std::basic_string<char>}')|

error: expected ']' before ')' token|

error: expected initializer before ')' token|

je ne comprend pas comment réparer les 3 premières erreur et je ne vois pas a quoi font référence les 2 dernières :/
si quelqu un pouvais me renseigner sa serais cool car je bloque la dessus depuis ce matin

et si vous voulez voir la liste d erreur dans son ensemble la voici

||=== Build: Debug in backtracking (compiler: GNU GCC Compiler) ===|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool valide(std::string (*)[5], int, int)'

C:\Users\User\Desktop\backtracking\main.cpp|83|note: operator&&(bool, bool) <built-in>|
C:\Users\User\Desktop\backtracking\main.cpp|83|note: no known conversion for argument 2 from 'std::basic_string<char>' to 'bool'|
C:\Users\User\Desktop\backtracking\main.cpp|87|error: no match for 'operator||' (operand types are 'const char [7]' and 'std::string {aka std::basic_string<char>}')|
C:\Users\User\Desktop\backtracking\main.cpp|87|note: candidate is

C:\Users\User\Desktop\backtracking\main.cpp|87|note: operator||(bool, bool) <built-in>|
C:\Users\User\Desktop\backtracking\main.cpp|87|note: no known conversion for argument 2 from 'std::string {aka std::basic_string<char>}' to 'bool'|
C:\Users\User\Desktop\backtracking\main.cpp|87|error: expected primary-expression before ')' token|
C:\Users\User\Desktop\backtracking\main.cpp|91|error: no match for 'operator||' (operand types are 'const char [8]' and 'std::string {aka std::basic_string<char>}')|
C:\Users\User\Desktop\backtracking\main.cpp|91|note: candidate is

C:\Users\User\Desktop\backtracking\main.cpp|91|note: operator||(bool, bool) <built-in>|
C:\Users\User\Desktop\backtracking\main.cpp|91|note: no known conversion for argument 2 from 'std::string {aka std::basic_string<char>}' to 'bool'|
C:\Users\User\Desktop\backtracking\main.cpp|95|error: no match for 'operator&&' (operand types are 'std::basic_string<char>' and 'std::basic_string<char>')|
C:\Users\User\Desktop\backtracking\main.cpp|95|note: candidate is

C:\Users\User\Desktop\backtracking\main.cpp|103|note: operator&&(bool, bool) <built-in>|
C:\Users\User\Desktop\backtracking\main.cpp|103|note: no known conversion for argument 2 from 'std::basic_string<char>' to 'bool'|
C:\Users\User\Desktop\backtracking\main.cpp|111|error: expected ']' before ')' token|
C:\Users\User\Desktop\backtracking\main.cpp|111|error: expected initializer before ')' token|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool AbsentSurColonne(std::string, std::string (*)[5], int)'

C:\Users\User\Desktop\backtracking\main.cpp|32|warning: control reaches end of non-void function [-Wreturn-type]|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool valide(std::string (*)[5], int, int)'

C:\Users\User\Desktop\backtracking\main.cpp|109|warning: control reaches end of non-void function [-Wreturn-type]|
||=== Build failed: 15 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

)

**ternel** · 23/11/2017, 14h49

Le problème, c'est que tu as confondu l'opérateur de comparaison ==, qui retourne (normalement) un bool, et l'opérateur d'affectation =, qui retourne (normalement) une référence sur l'élément de gauche, qui est modifié.

**joe0703** · 23/11/2017, 14h52

je vois ce que tu veux dire mais par contre je ne vois pas comment modifier mon code pour que cela puisse dire la meme chose et fonctionner
:/
car on ne peut pas cree une variable "contrainte = ((maison[i][1]="anglais") && (maison[i][0]="rouge"))
et dire apres
if !(contrainte)

si ?

j avais mal lu ton message mdr :p
j ai donc mis les == a la place des =

donc ca ma enlever les premiere erreurs
merci a toi

j en suis donc a

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
162
163
164
165
166
167
168
169
170
171
172
173
174
#include <iostream>
 
using namespace std;
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de separer les block de maniere vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien abscente d une colonne
 
bool AbsentSurColonne ( string k, string grille[5][5],int j)
{
    for ( int i=0; i<5; i++)
    {
        if ( grille[i][j]==k)//si la valeur est deja presente sur la colonne
            return false;
        return true;
    }
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entree et la reseoudre
 
//nous devons constamment verifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va doonc utiliser le retour de la fonction pour nous indiquer si la grille est valide ou non
//enfin , comme notre fonction doit etre recursive, nous allonns ajouter un parametre pour savoir quelle case nous somme en train de trater
 
//une case (i,j) dans un tableau peut etre representer par un nombre (i*largeur_tableau)+j, que nous nommerons position
 
bool valide( string maison[5][5], int i ,int a )
{
 
//sur une même ligne: les valeurs doivent être différentes
  for(int k=0;k<i;k++)
   {
        if(maison[i][a]==maison[k][a])
            return false;
   }
 
    //On boit du lait dans la maison du milieu.
    if( !(maison[2][3]=="lait"))
        return false ;
 
	//– L'Anglais habite la maison rouge
	if( !((maison[i][1]=="anglais") && (maison[i][0]=="rouge")))
        return false ;
 
	//– Le chien appartient à l'Espagnol.
	if( !((maison[i][1]=="espagnol") && (maison[i][4]=="chien")))
        return false ;
 
	//– On boit du café dans la maison verte.
	if( !((maison[i][2]=="cafe") && (maison[i][0]=="verte")))
        return false  ;
 
	//– L'Ukrainien boit du thé.
	if( !((maison[i][1]=="ukrainien") && (maison[i][2]=="the")))
        return false;
 
	//– La maison verte est à côté de la blanche, à droite.
	if( !((maison[i][0]=="blanche") && (maison[i+1][0]=="verte")))
        return false ;
 
	//– Le fumeur de Old Gold élève des escargots.
	if( !((maison[i][4]=="escargots") && (maison[i][3]=="old")))
        return false;
 
	//– On fume des Kool dans la maison jaune.
	if( !((maison[i][3]=="kool") && (maison[i][0]=="jaune")))
        return false ;
 
	//– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
	if( !((maison[i][3]=="chesterfield") && ((maison[i+1][4]=="renard") || (maison[i-1][4])=="renard" )))
        return false;
 
	//– Le fumeur de Kool habite à côté du propriétaire du cheval.
	if( !((maison[i][3]=="kool") && (( maison[i+1][4]=="chevale") || (maison[i-1][4]=="cheval"))))
        return false;
 
	//– Le fumeur de gitanes boit du vin.
	if( !((maison[i][2]=="vin") && (maison[i][3]=="gitane" )))
        return false ;
 
	//– Le Japonais fume des Craven.
	if( !((maison[i][3]=="craven") && (maison[i][1]=="japonais" )))
        return false;
 
	//– Le Norvégien habite à côté de la maison bleue. et le norvegien habite la premiere maison a gauche
	if( !((maison[0][1]=="norvegien") && (maison[1][0]=="bleu")))
        return false ;
 
	else
        return true;
 
}
 
bool estValide (string grille[5][5], int position, string tableau[5),tableau [5])
{
    // si on est a la 25eme case ( on sort du tableau)
    if(position == 5*5)
        return true;
 
    //on recupere les coordonnees de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel recursif)
    if (grille[i][j] !="0")
        return estValide(grille, position +1, tableau[5]);
 
    //enumeration des valeurs possible
    for(int k = 0; k<5 ; k++)
    {
        //si la valeur est abscente ,et si elle repond au contrainte
        if(AbsentSurColonne(tableau[k],grille,i)&& valide )
        {
            //on enregistre dans la grille
            grille[i][j];
            // on appelle recursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( est valide (grille, position+1,tableau[5]))
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
    //toutes les valeur ont ete testes, aucun n'est bon , on reinitialise la case
    grille[i][j] = "0";
    //puis on retourn faux
    return false;
}
 
int main ()
{
    //avant tout, on donner les variable possible grace a des tableau
    string couleur [5] = {rouge,verte,jaune,bleu,blanche}
    string nationalite [5] = {anglais,espagnol,norvegien,japonais,ukrainien}
    string boisson [5]= {eau,the,cafe,vin,lait}
    string cigarette [5]= {craven,old,kool,chesterfiel,gitane}
    string animaux [5]= {zebre,renard,chien,cheval,escargots}
   //  nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on cree un tableau en deux dimension
    //les grille vides etant representer par des 0
    int grille[5][5] =
    {
        {0,0,0,0,0},// couleur
        {0,0,0,0,0},//nationalite
        {0,0,0,0,0},//boisson
        {0,0,0,0,0},//cigarette
        {0,0,0,0,0}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,couleur);
    estValide(grille,0,nationalite);
    estValide(grille,0,boisson);
    estValide(grille,0,cigarette);
    estValide(grille,0,animaux);
    cout<<"grille apres"<<endl;
    affichage(grille);
}

et

|
||=== Build: Debug in backtracking (compiler: GNU GCC Compiler) ===|
C:\Users\User\Desktop\backtracking\main.cpp|111|error: expected ']' before ')' token|
C:\Users\User\Desktop\backtracking\main.cpp|111|error: expected initializer before ')' token|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool AbsentSurColonne(std::string, std::string (*)[5], int)'

C:\Users\User\Desktop\backtracking\main.cpp|32|warning: control reaches end of non-void function [-Wreturn-type]|
||=== Build failed: 2 error(s), 1 warning(s) (0 minute(s), 0 second(s)) ===|

**ternel** · 23/11/2017, 15h03

Code :

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

if( !((maison[i][1]=="anglais") && (maison[i][0]=="rouge") )) {

Voire, avec une variable intermédiaire:

Code :

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

1
2
auto const condition = (maison[i][1]=="anglais") && (maison[i][0]=="rouge");
if (!condition) {

(tu peux aussi la définir commme bool const. En fait, auto sera déduit en bool.

Quant à ton dernier problème, en général ce sont des ; manquants.
Regardes les lignes 146 et suivantes.

**Bousk** · 23/11/2017, 15h04

std::vector et std::array non ?

Quant à ton erreur, commence par la lire parce qu'elle est on ne peut plus explicite

bool estValide (string grille[5][5], int position, string tableau[5),tableau [5])

**joe0703** · 23/11/2017, 15h05

pas le droit mdr ^^ sa serais trop simple sinon mdr :p

par contre j ai réussi a réparer la majeur partis des erreurs a l'aide des message precedent, il ne reste plus que celle ci

||=== Build: Debug in backtracking (compiler: GNU GCC Compiler) ===|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool estValide(std::string (*)[5], int, std::string*)'

C:\Users\User\Desktop\backtracking\main.cpp|129|error: cannot convert 'std::string {aka std::basic_string<char>}' to 'std::string (*)[5] {aka std::basic_string<char> (*)[5]}' for argument '1' to 'bool estValide(std::string (*)[5], int, std::string*)'|
C:\Users\User\Desktop\backtracking\main.cpp|135|warning: the address of 'bool valide(std::string (*)[5])' will always evaluate as 'true' [-Waddress]|
C:\Users\User\Desktop\backtracking\main.cpp|138|warning: statement has no effect [-Wunused-value]|
C:\Users\User\Desktop\backtracking\main.cpp|140|error: cannot convert 'std::string {aka std::basic_string<char>}' to 'std::string* {aka std::basic_string<char>*}' for argument '3' to 'bool estValide(std::string (*)[5], int, std::string*)'|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool AbsentSurColonne(std::string, std::string (*)[5], int)'

C:\Users\User\Desktop\backtracking\main.cpp|32|warning: control reaches end of non-void function [-Wreturn-type]|
C:\Users\User\Desktop\backtracking\main.cpp||In function 'bool valide(std::string (*)[5])'

C:\Users\User\Desktop\backtracking\main.cpp|116|warning: control reaches end of non-void function [-Wreturn-type]|
||=== Build failed: 2 error(s), 4 warning(s) (0 minute(s), 0 second(s)) ===|

et donc le code corriger donne

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
 
#include <iostream>
 
using namespace std;
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de separer les block de maniere vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien abscente d une colonne
 
bool AbsentSurColonne ( string k, string grille[5][5],int j)
{
    for ( int i=0; i<5; i++)
    {
        if ( grille[i][j]==k)//si la valeur est deja presente sur la colonne
            return false;
        return true;
    }
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entree et la reseoudre
 
//nous devons constamment verifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va doonc utiliser le retour de la fonction pour nous indiquer si la grille est valide ou non
//enfin , comme notre fonction doit etre recursive, nous allonns ajouter un parametre pour savoir quelle case nous somme en train de trater
 
//une case (i,j) dans un tableau peut etre representer par un nombre (i*largeur_tableau)+j, que nous nommerons position
 
bool valide( string maison[5][5])
{
 
//sur une même ligne: les valeurs doivent être différentes
    for(int k=0;k<5;k++)
    {
        for(int i=0;i<5;i++)
        {
            for(int a=0;a<5;a++)
            {
                if(maison[i][a]==maison[k][a])
                return false;
            }
 
    //On boit du lait dans la maison du milieu.
    if( !(maison[2][3]=="lait"))
        return false ;
 
	//– L'Anglais habite la maison rouge
	if( !((maison[i][1]=="anglais") && (maison[i][0]=="rouge")))
        return false ;
 
	//– Le chien appartient à l'Espagnol.
	if( !((maison[i][1]=="espagnol") && (maison[i][4]=="chien")))
        return false ;
 
	//– On boit du café dans la maison verte.
	if( !((maison[i][2]=="cafe") && (maison[i][0]=="verte")))
        return false  ;
 
	//– L'Ukrainien boit du thé.
	if( !((maison[i][1]=="ukrainien") && (maison[i][2]=="the")))
        return false;
 
	//– La maison verte est à côté de la blanche, à droite.
	if( !((maison[i][0]=="blanche") && (maison[i+1][0]=="verte")))
        return false ;
 
	//– Le fumeur de Old Gold élève des escargots.
	if( !((maison[i][4]=="escargots") && (maison[i][3]=="old")))
        return false;
 
	//– On fume des Kool dans la maison jaune.
	if( !((maison[i][3]=="kool") && (maison[i][0]=="jaune")))
        return false ;
 
	//– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
	if( !((maison[i][3]=="chesterfield") && ((maison[i+1][4]=="renard") || (maison[i-1][4])=="renard" )))
        return false;
 
	//– Le fumeur de Kool habite à côté du propriétaire du cheval.
	if( !((maison[i][3]=="kool") && (( maison[i+1][4]=="chevale") || (maison[i-1][4]=="cheval"))))
        return false;
 
	//– Le fumeur de gitanes boit du vin.
	if( !((maison[i][2]=="vin") && (maison[i][3]=="gitane" )))
        return false ;
 
	//– Le Japonais fume des Craven.
	if( !((maison[i][3]=="craven") && (maison[i][1]=="japonais" )))
        return false;
 
	//– Le Norvégien habite à côté de la maison bleue. et le norvegien habite la premiere maison a gauche
	if( !((maison[0][1]=="norvegien") && (maison[1][0]=="bleu")))
        return false ;
 
	else
        return true;
 
        }
   }
 
}
 
bool estValide (string grille[5][5], int position, string tableau[5])
{
    // si on est a la 25eme case ( on sort du tableau)
    if(position == 5*5)
        return true;
 
    //on recupere les coordonnees de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel recursif)
    if (grille[i][j] !="0")
        return estValide(grille[5][5], position +1, tableau[5]);
 
    //enumeration des valeurs possible
    for(int k = 0; k<5 ; k++)
    {
        //si la valeur est abscente ,et si elle repond au contrainte
        if(AbsentSurColonne(tableau[k],grille,i)&& valide )
        {
            //on enregistre dans la grille
            grille[i][j];
            // on appelle recursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( estValide (grille, position+1,tableau[5]))
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
    //toutes les valeur ont ete testes, aucun n'est bon , on reinitialise la case
    grille[i][j] = "0";
    //puis on retourn faux
    return false;
}
 
int main ()
{
    //avant tout, on donner les variable possible grace a des tableau
    string couleur [5] = {"rouge","verte","jaune","bleu","blanche"};
    string nationalite [5] = {"anglais","espagnol","norvegien","japonais","ukrainien"};
    string boisson [5]= {"eau","the","cafe","vin","lait"};
    string cigarette [5]= {"craven","old","kool","chesterfiel","gitane"};
    string animaux [5]= {"zebre","renard","chien","cheval","escargots"};
   //  nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on cree un tableau en deux dimension
    //les grille vides etant representer par des 0
    string grille[5][5] =
    {
        {"0","0","0","0","0"},// couleur
        {"0","0","0","0","0"},//nationalite
        {"0","0","0","0","0"},//boisson
        {"0","0","0","0","0"},//cigarette
        {"0","0","0","0","0"}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,couleur);
    estValide(grille,0,nationalite);
    estValide(grille,0,boisson);
    estValide(grille,0,cigarette);
    estValide(grille,0,animaux);
    cout<<"grille apres"<<endl;
    affichage(grille);
}

**joe0703** · 23/11/2017, 20h19

bon j ai réussi a résoudre toutes les erreurs
mais le soucis est que mon code compile mais ne fait rien du tout mdr ^^' il ne modifie pas mon tableau bidimensionnelle
et l affichage me donne donc le mm tableau avant et apres

**bacelar** · 23/11/2017, 20h27

Utilisez un débogueur.

**joe0703** · 23/11/2017, 21h04

j utilise codeblock qui en a normalement un intégrer si je ne dit pas de bêtise
et il ne m affiche plus d erreur

-------------- Build: Debug in backtracking (compiler: GNU GCC Compiler)---------------

Target is up to date.
Nothing to be done (all items are up-to-date).

-------------- Run: Debug in backtracking (compiler: GNU GCC Compiler)---------------

Checking for existence: C:\Users\User\Desktop\backtracking\bin\Debug\backtracking.exe
Executing: "C:\Program Files (x86)\CodeBlocks/cb_console_runner.exe" "C:\Users\User\Desktop\backtracking\bin\Debug\backtracking.exe" (in C:\Users\User\Desktop\backtracking\.)
Process terminated with status -1073741510 (0 minute(s), 14 second(s))

-------------- Build: Debug in backtracking (compiler: GNU GCC Compiler)---------------

Target is up to date.
Nothing to be done (all items are up-to-date).

Je sais que le soucis vient de ma fonction "valide" car dans la fonction estValide je ne traite qu'un seule tableau ( couleur nationaliter ...ect ) a la fois mais je ne sais pas comment modifier mon code pour que cela fonctionne :'(
voila ce que j'ai tenter pour reusir a réparer l'erreur

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
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
202
203
#include <iostream>
 
using namespace std;
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de separer les block de maniere vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien abscente d une colonne
 
bool AbsentSurColonne ( string k, string grille[5][5],int j)
{
    for ( int i=0; i<5; i++)
    {
        if ( grille[i][j]==k)//si la valeur est deja presente sur la colonne
            return false;
    }
           return true;
}
bool AbsentSurLigne ( string k, string grille[5][5],int i)
{
    for ( int j=0; j<5; j++)
    {
        if ( grille[i][j]==k)//si la valeur est deja presente sur la colonne
            return false;
    }
           return true;
}
// Prototype de la fonction
// Cette fonction va recevoir une grille en entree et la reseoudre
 
//nous devons constamment verifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va doonc utiliser le retour de la fonction pour nous indiquer si la grille est valide ou non
//enfin , comme notre fonction doit etre recursive, nous allonns ajouter un parametre pour savoir quelle case nous somme en train de trater
 
//une case (i,j) dans un tableau peut etre representer par un nombre (i*largeur_tableau)+j, que nous nommerons position
 
bool valide( string maison[5][5])
{
 
//sur une même ligne et sur un meme colonne: les valeurs doivent être différentes
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            for(int k=0;k<5;k++)
            {
                if(maison[i][j]==maison[k][j])
                    return false;
                if(maison[i][j]==maison[i][k])
                    return false;
 
                //On boit du lait dans la maison du milieu.
                if( !(maison[2][3]=="lait"))
                    return false ;
 
                //– L'Anglais habite la maison rouge
                if( !((maison[i][1]=="anglais") && (maison[i][0]=="rouge")))
                    return false ;
 
                //– Le chien appartient à l'Espagnol.
                if( !((maison[i][1]=="espagnol") && (maison[i][4]=="chien")))
                    return false ;
 
                //– On boit du café dans la maison verte.
                if( !((maison[i][2]=="cafe") && (maison[i][0]=="verte")))
                    return false  ;
 
                //– L'Ukrainien boit du thé.
                if( !((maison[i][1]=="ukrainien") && (maison[i][2]=="the")))
                    return false;
 
                //– La maison verte est à côté de la blanche, à droite.
                if( !((maison[i][0]=="blanche") && (maison[i+1][0]=="verte")))
                    return false ;
 
                //– Le fumeur de Old Gold élève des escargots.
                if( !((maison[i][4]=="escargots") && (maison[i][3]=="old")))
                    return false;
 
                //– On fume des Kool dans la maison jaune.
                if( !((maison[i][3]=="kool") && (maison[i][0]=="jaune")))
                    return false ;
 
                //– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
                if( !((maison[i][3]=="chesterfield") && ((maison[i+1][4]=="renard") || (maison[i-1][4])=="renard" )))
                    return false;
 
                //– Le fumeur de Kool habite à côté du propriétaire du cheval.
                if( !((maison[i][3]=="kool") && (( maison[i+1][4]=="chevale") || (maison[i-1][4]=="cheval"))))
                    return false;
 
                //– Le fumeur de gitanes boit du vin.
                if( !((maison[i][2]=="vin") && (maison[i][3]=="gitane" )))
                    return false ;
 
                //– Le Japonais fume des Craven.
                if( !((maison[i][3]=="craven") && (maison[i][1]=="japonais" )))
                    return false;
 
                //– Le Norvégien habite à côté de la maison bleue. et le norvegien habite la premiere maison a gauche
                if( !((maison[0][1]=="norvegien") && (maison[1][0]=="bleu")))
                    return false ;
            }
        }
    }
    return true;
}
 
bool estValide (string grille[5][5], int position, string tableau[25])
{
    // si on est a la 25eme case ( on sort du tableau)
    if(position == 5*5)
        return true;
 
    //on recupere les coordonnees de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel recursif)
    if (grille[i][j] !="0")
        return estValide(grille, (position +1), tableau);
 
    //enumeration des valeurs possible
    for(int k = 0; k<25 ; k++)
    {
        //si la valeur est abscente ,et si elle repond au contrainte
        if(AbsentSurColonne(tableau[k],grille,i)&& AbsentSurLigne(tableau[k],grille,j) )
        {
            //on enregistre dans la grille
            grille[i][j]=tableau[k];
            // on appelle recursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( estValide (grille, position+1,tableau))
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
        if (!(valide))
            {
                for (int i=0; i<5;i++)
                {
                    for (int j=0; j<5;j++)
                        {
                               grille[i][j] = "0";
                        }
                }
            }
    }
 
    //toutes le s valeur ont ete testes, aucun n'est bon , on reinitialise la case
    grille[i][j] = "0";
    //puis on retourn faux
    return false;
}
 
int main ()
{
 
    //avant tout, on donner les variable possible grace a des tableau
 
     string couleur [25] = {"rouge","verte","jaune","bleu","blanche","anglais","espagnol","norvegien","japonais","ukrainien","eau","the","cafe","vin","lait","craven","old","kool","chesterfiel","gitane","zebre","renard","chien","cheval","escargots"};
    //string couleur [5] = {"rouge","verte","jaune","bleu","blanche"};
    //string nationalite [5] = {"anglais","espagnol","norvegien","japonais","ukrainien"};
    //string boisson [5]= {"eau","the","cafe","vin","lait"};
    //string cigarette [5]= {"craven","old","kool","chesterfiel","gitane"};
    //string animaux [5]= {"zebre","renard","chien","cheval","escargots"};
 
    // nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on cree un tableau en deux dimension
    //les grille vides etant representer par des "0"
 
    string grille[5][5] =
    {
        {"0","0","0","0","0"},// couleur
        {"0","0","0","0","0"},//nationalite
        {"0","0","0","0","0"},//boisson
        {"0","0","0","0","0"},//cigarette
        {"0","0","0","0","0"}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,couleur);
   // estValide(grille,0,nationalite);
    //estValide(grille,0,boisson);
    //estValide(grille,0,cigarette);
    //estValide(grille,0,animaux);
    cout<<"grille apres"<<endl;
    affichage(grille);
}

et voila ce que j'obtient malheureusement

grille avant
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------

grille apres
------------------------------
| rouge | verte | verte | verte | verte |
------------------------------
| jaune | rouge | jaune | jaune | jaune |
------------------------------
| bleu | bleu | rouge | bleu | bleu |
------------------------------
| blanche | blanche | blanche | rouge | blanche |
------------------------------
| anglais | anglais | anglais | anglais | rouge |
------------------------------

Process returned 0 (0x0) execution time : 0.047 s
Press any key to continue.

**bacelar** · 24/11/2017, 11h09

Vous confondez compilateur et débogueur.
Utilisez le mode pas à pas du débogueur.

**joe0703** · 24/11/2017, 17h49

bon j'y est passer toutes la journée mais j'ai finalement réussi a corriger tous les bugs
Le soucis désormais est que mon code ne fait pas exactement ce qu'il devrait faire et je n'arrive pas a comprendre pourquoi

je devrait obtenir ceci

grille avant
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------

grille apres
------------------------------
| jaune| bleu | rouge | blanche | verte |
------------------------------
| norvegien | ukrainien | anglais | espagnol | japonais |
------------------------------
| eau | the | lait | vin | cafe |
------------------------------
| kool | chesterfiel | old | gitane | craven |
------------------------------
| renard | cheval | escargots | chien | zebre |
------------------------------

Process returned 0 (0x0) execution time : 0.051 s
Press any key to continue.

qui repond a toutes mes condition
mais j'obtient cela

grille avant
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------
| 0 | 0 | 0 | 0 | 0 |
------------------------------

grille apres
------------------------------
| rouge | verte | jaune | bleu | blanche |
------------------------------
| anglais | espagnol | norvegien | japonais | ukrainien |
------------------------------
| eau | the | cafe | vin | lait |
------------------------------
| craven | old | kool | chesterfiel | gitane |
------------------------------
| zebre | renard | chien | cheval | escargots |
------------------------------

Process returned 0 (0x0) execution time : 0.051 s
Press any key to continue.

qui lui ne repond pas a toute mes conditions
je ne comprend pas comment cela se fait alors que j ai une vérification en BOOL pour que cela ne se produise pas
si quelqu'un pouvais m'aider a comprendre ou cela peut clocher je lui en serais gres :/

mon nouveau code etant celui ci

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
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#include <iostream>
 
using namespace std;
 
 
bool condition1( string maison[5][5])
{
    //On boit du lait dans la maison du milieu.
    if( !(maison[2][3]=="lait"))
        return false ;
    return true;
}
 
bool condition2( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– L'Anglais habite la maison rouge
        // la maison0 et la maison1 ne sont donc pas compatible on commence donc a la maison 2
        if( (maison[i][1]=="anglais") && (maison[i][0]=="rouge") && i!=0 && i!= 1)
            return true ;
    }
    return false;
}
 
bool condition3( string maison[5][5])
{
   for(int i=0;i<5;i++)
    {
        //– Le chien appartient à l'Espagnol.
        //la maison 0 ne correspond pas on commence donc a la maison 1
        if( (maison[i][1]=="espagnol") && (maison[i][4]=="chien") && i!=0)
            return true ;
    }
    return false;
}
 
bool condition4( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– La maison verte est à côté de la blanche, à droite.
        //– On boit du café dans la maison verte.
        //la maison blanche ne peut donc pas être la maison 4 car la verte doit être a sa droite
        //et la maison 0 ne peut pas être la blanche vu que celle a sa droite est la maison bleu , donc la maison verte ne peut pas être la maison 1
        if((maison[i][0]=="blanche") && (maison[i+1][0]=="verte" ) && (maison[i+1][2]=="cafe") && i!=0 && i!=4 && i !=1)
            return true ;
    }
    return false;
}
 
bool condition5( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– L'Ukrainien boit du thé.
        if( i!=2 && i!=0 && ((maison[i][1]=="ukrainien") && (maison[i][2]=="the")))
            return true;
    }
    return false;
}
 
bool condition6( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– On fume des Kool dans la maison jaune.
        //– Le fumeur de Kool habite à côté du propriétaire du cheval.
        // la maison 1 n'est donc pas la bonne
        if( (maison[i][3]=="kool") && (maison[i][0]=="jaune")&& (((( maison[i+1][4]=="cheval")&& i!=4) ||((maison[i-1][4]=="cheval")&& i!=0)) && i!=1))
            return true ;
    }
    return false;
 
}
 
bool condition7( string maison[5][5])
{
    //– Le Norvégien habite à côté de la maison bleue. et le norvégien habite la première maison a gauche
    // la maison 0 est donc celle du norvégien et la maison 1 est donc bleu
    if( (maison[0][1]=="norvegien") && (maison[1][0]=="bleu"))
        return true ;
 
    return false;
}
 
bool condition8( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– On fume des Kool dans la maison jaune.
        //– Le fumeur de Kool habite à côté du propriétaire du cheval.
        // la maison 1 ne peut pas être celle ci vu qu elle est bleu
        if( (maison[i][3]=="kool") && (maison[i][0]=="jaune")&& ((( maison[i+1][4]=="cheval") && i!= 4) || ((maison[i-1][4]=="cheval")&& i!=0))&& i!=1)
            return true ;
    }
    return false;
}
 
bool condition9( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de gitanes boit du vin.
        // ce n'est pas celle du milieu vu que l on y bois du lait
        if( (maison[i][2]=="vin") && (maison[i][3]=="gitane" ) && i!=2)
            return true ;
    }
    return false;
}
 
bool condition10( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– Le Japonais fume des Craven.
        if( (maison[i][3]=="craven") && (maison[i][1]=="japonais" ) && i!=0)
            return true ;
    }
    return false;
}
 
bool condition11( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
         //– Le fumeur de Old Gold élève des escargots.
        if( (maison[i][4]=="escargots") && (maison[i][3]=="old"))
            return true;
    }
    return false;
}
 
bool condition12( string maison[5][5])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
        if((maison[i][3]=="chesterfield") && (((maison[i+1][4]=="renard")&& i!=4) || ((maison[i-1][4]=="renard" )&& i!=0)))
            return true;
    }
    return false;
}
 
bool valide ( string grille[5][5])
{
    if (!(condition1(grille)) || !(condition2(grille)) || !(condition3(grille)) || !(condition4(grille)) || !(condition5(grille))||!(condition6(grille))||!(condition7(grille))||!(condition8(grille))||!(condition9(grille))||!(condition10(grille))||
        !(condition11(grille))||!(condition12(grille)))
        return false;
    return true;
}
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de séparer les blocs de manière vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien absente d une colonne
 
bool AbsentSurBlock ( string k, string grille[5][5],int i, int j)
{
    for ( int i=0; i<5; i++)
    {
        for ( int j=0; j<5; j++)
        {
            if ( grille[i][j]==k)//si la valeur est déjà présente sur le blocs
                return false;
        }
    }
    return true;
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entrée et la résoudre
 
//nous devons constamment vérifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va donc utiliser le retour de la fonction pour nous indiquer si la grille est valide ou non
//enfin , comme notre fonction doit être récursive, nous allons ajouter un paramètre pour savoir quelle case nous somme en train de traiter
 
//une case (i,j) dans un tableau peut être représenter par un nombre (i*largeur_tableau)+j, que nous nommerons position
bool estValide (string grille[5][5], int position, string tableau[25])
{
    // si on est a la 25eme case ( on sort du tableau)
    if(position == 5*5)
        return true;
 
    //on récupère les coordonnées de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel récursif)
    if (grille[i][j] !="0")
        return estValide(grille, (position +1), tableau);
 
    //énumération des valeurs possible
    for(int k = 0; k<25 ; k++)
    {
        //si la valeur est absente ,et si elle répond au contrainte
        if(AbsentSurBlock(tableau[k],grille,i,j)|| valide(grille))
        {
            //on enregistre dans la grille
            grille[i][j]=tableau[k];
            // on appelle récursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( estValide (grille, position+1,tableau) )
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
    if (!(valide(grille)))
    {
        //toutes les valeur ont été testes, aucunes n'est bonnes , on réinitialise la case
        grille[i][j] = "0";
        return estValide(grille, (position -1), tableau);
    }
 
    //puis on retourne faux
    return false;
}
 
int main ()
{
 
    //avant tout, on donner les variable possible grâce a des tableau
 
     string info [25] = {"rouge","verte","jaune","bleu","blanche","anglais","espagnol","norvegien","japonais","ukrainien","eau","the","cafe","vin","lait","craven","old","kool","chesterfiel","gitane","zebre","renard","chien","cheval","escargots"};
 
    // nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on crée un tableau en deux dimension
    //les grille vides étant représenter par des "0"
 
    string grille[5][5] =
    {
        {"0","0","0","0","0"},// couleur
        {"0","0","0","0","0"},//nationalité
        {"0","0","0","0","0"},//boisson
        {"0","0","0","0","0"},//cigarette
        {"0","0","0","0","0"}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,info);
 
    cout<<"grille après"<<endl;
    affichage(grille);
}

J AI MODIFIER LE CODE

**bacelar** · 24/11/2017, 19h01

Bon, code super complexe pour pas grand-chose.
Il aurait été bien plus simple d'utiliser des types de données bien plus explicites et cela aurait permis de voir bon nombre de boulette qui constelle votre programme.
Et avec des types qui ressemble à des vrais types et pas cet infâme tableau C à 2 dimension de std::string, comme un std::array<QuintupletSolution,5> vous auriez pu utiliser toutes les fonctionnalités de la STL standard, les algorithmes en particulier, pour ne pas refaire, en beaucoup moins bien, la roue.
Vous mettez les valeurs de n'importe quelle catégorie dans n'importe quel slot, le fait que le résultat obtenu ne mélange pas des choux et les carottes tient du miracle.

Vous affichez la grille ligne 257, sans même vérifier que le résultat ligne 255 est "vrai".
Si le problème n'est pas soluble, vous faites quoi ?
Et il ne sera peut-être pas parce que vous avez merdé dès l'implémentation de la condition1 (encore un nom à la con, pour pas "checkMilkOnCentralHouse" ?, vous avez peur d'user votre clavier ou l'ordinateur avec le completion automatique ???).
Le lait il est censé être dans quel ligne ? Vous le cherchez dans la 4ème ligne au lieu de la 3ème (les indices de tableau commence à 0).

On niveau du nommage des méthodes, c'est la foire à la saucisse, la subtile différence entre "valide" et "estValide" m'interpelle.

Vos méthodes conditions sont truffées de valeurs en dur, les enum et les constexpr, c'est en option ?
Vos méthodes conditions font de l'optimisation prématurée, commencez par un truc qui fonctionne, puis on mesure les performances, puis on optimise.
Comme les types des données à base de std::string, c'est pire que dans un langage de script, la validité du code, c'est à faire dans mon cerveau qui autre chose à faire.
Déjà que ça part en couille dés condition1, je regarde même pas.
Mais, bon, l'utilisation de "i+1" et autre "i-1" sur des bornes de boucle de 0 à 4, ça sent des débordements de tableau dans tous les coins, pas vérifier parce qu'on utilise un tableau à la C, DE MERDE.

Ligne 211, vous lancer valide sur l'ancienne grille, pas sur la "nouvelle proposition".

Votre mécanisme de récursion qui revient en arrière via "position -1" ligne 224 n'est absolument pas logique.

**joe0703** · 24/11/2017, 20h11

sauf que j ai pas le droit d utiliser les bibliotheque disponible
si j y avais le droit sa serais simple et donc sans interet pour les prof

heuuu ? pour lait pas compris

Code :

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

1
2
3
4
5
6
7
8
 
bool condition1( string maison[5][5])
{
    //On boit du lait dans la maison du milieu.
    if( !(maison[2][3]=="lait"))
        return false ;
    return true;
}

il doit être dans la colonne 2 ligne 3 et cela en prenant en compte que le tableau par de 0 jusqu a 4 aussi bien en largeur qu en hauteur

pour le i+1 et le i-1 si tu lis la condition jusqu au bot je précise &&i!=4 && i != de 0 donc la non plus je vois pas ou est le soucis vu que i est différent dans deux extrémités il ne peut pas y avoir de débordement

après pour les appellation comment qu elle s'appel n'est pas vraiment important tant qu'elles n on pas le meme nom , apres cela reste un tp mais je le change pour te faire plaisir

pour le reste j'ai modifier le code meme si cela ne change pas grand chose au 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
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
#include <iostream>
 
using namespace std;
 
 
bool positionLait( string grille[5][5],string info[25])
{
 
    //On boit du lait dans la info du milieu.
    if( !(grille[2][3]==info[14]))
        return false ;
    return true;
}
 
bool positionAnglaisRouge( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– L'Anglais habite la info rouge
        // la info0 et la info1 ne sont donc pas compatible on commence donc a la info 2
        if( (grille[i][1]==info[5]) && (grille[i][0]==info[0]) && i!=0 && i!= 1)
            return true ;
    }
    return false;
}
 
bool positionChienEspagnol( string grille[5][5],string info[25])
{
   for(int i=0;i<5;i++)
    {
        //– Le chien appartient à l'Espagnol.
        //la info 0 ne correspond pas on commence donc a la info 1
        if( (grille[i][1]==info[6]) && (grille[i][4]==info[22]) && i!=0)
            return true ;
    }
    return false;
}
 
bool positionVerteBlancheCafe( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– La info verte est à côté de la blanche, à droite.
        //– On boit du café dans la info verte.
        //la info blanche ne peut donc pas être la info 4 car la verte doit être a sa droite
        //et la info 0 ne peut pas être la blanche vu que celle a sa droite est la info bleu , donc la info verte ne peut pas être la info 1
        if((grille[i][0]=="blanche") && (grille[i+1][0]=="verte" ) && (grille[i+1][2]=="cafe") && i!=0 && i!=4 && i !=1)
            return true ;
    }
    return false;
}
 
bool positionUkrainienThe( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– L'Ukrainien boit du thé.
        if( i!=2 && i!=0 && ((grille[i][1]=="ukrainien") && (grille[i][2]=="the")))
            return true;
    }
    return false;
}
 
bool positionJauneKoolVoisinCheval( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– On fume des Kool dans la info jaune.
        //– Le fumeur de Kool habite à côté du propriétaire du cheval.
        // la info 1 n'est donc pas la bonne
        if( (grille[i][3]=="kool") && (grille[i][0]=="jaune")&& (((( grille[i+1][4]=="cheval")&& i!=4) ||((grille[i-1][4]=="cheval")&& i!=0)) && i!=1))
            return true ;
    }
    return false;
 
}
 
bool positionNorvegienAGaucheVoisinBleu( string grille[5][5],string info[25])
{
    //– Le Norvégien habite à côté de la info bleue. et le norvégien habite la première info a gauche
    // la info 0 est donc celle du norvégien et la info 1 est donc bleu
    if( (grille[0][1]=="norvegien") && (grille[1][0]=="bleu"))
        return true ;
 
    return false;
}
 
bool positionGitaneVin( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de gitanes boit du vin.
        // ce n'est pas celle du milieu vu que l on y bois du lait
        if( (grille[i][2]=="vin") && (grille[i][3]=="gitane" ) && i!=2)
            return true ;
    }
    return false;
}
 
bool positionJaponaisCraven( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le Japonais fume des Craven.
        if( (grille[i][3]=="craven") && (grille[i][1]=="japonais" ) && i!=0)
            return true ;
    }
    return false;
}
 
bool positionOldEscargots( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
         //– Le fumeur de Old Gold élève des escargots.
        if( (grille[i][4]=="escargots") && (grille[i][3]=="old"))
            return true;
    }
    return false;
}
 
bool positionChesterfieldVoisinRenard( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
        if((grille[i][3]=="chesterfield") && (((grille[i+1][4]=="renard")&& i!=4) || ((grille[i-1][4]=="renard" )&& i!=0)))
            return true;
    }
    return false;
}
 
bool toutesConditions ( string grille[5][5],string info[25])
{
    if (!(positionLait(grille,info)) || !(positionAnglaisRouge(grille,info)) || !(positionChienEspagnol(grille,info)) || !(positionVerteBlancheCafe(grille,info)) || !(positionUkrainienThe(grille, info))||!(positionJauneKoolVoisinCheval(grille, info))||!(positionNorvegienAGaucheVoisinBleu(grille, info))||!(positionGitaneVin(grille, info))||!(positionJaponaisCraven(grille, info))||
        !(positionOldEscargots(grille,info))||!(positionChesterfieldVoisinRenard(grille,info)))
        return false;
    return true;
}
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de séparer les blocs de manière vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien absente d une colonne
 
bool AbsentSurBlock ( string k, string grille[5][5],int i, int j)
{
    for ( int i=0; i<5; i++)
    {
        for ( int j=0; j<5; j++)
        {
            if ( grille[i][j]==k)//si la valeur est déjà présente sur le blocs
                return false;
        }
    }
    return true;
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entrée et la résoudre
 
//nous devons constamment vérifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va donc utiliser le retour de la fonction pour nous indiquer si la grille est toutesConditions ou non
//enfin , comme notre fonction doit être récursive, nous allons ajouter un paramètre pour savoir quelle case nous somme en train de traiter
 
//une case (i,j) dans un info peut être représenter par un nombre (i*largeur_info)+j, que nous nommerons position
bool estValide (string grille[5][5], int position, string info[25])
{
    // si on est a la 25eme case ( on sort du info)
    if(position == 5*5)
        return true;
 
    //on récupère les coordonnées de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel récursif)
    if (grille[i][j] !="0")
        return estValide(grille, (position +1), info);
 
    //énumération des valeurs possible
    for(int k = 0; k<25 ; k++)
    {
        //si la valeur est absente ,et si elle répond au contrainte
        if(AbsentSurBlock(info[k],grille,i,j))
        {
            //on enregistre dans la grille
            grille[i][j]=info[k];
            // on appelle récursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( estValide (grille, position+1,info)&&  toutesConditions(grille,info) )
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
 
    //toutes les valeur ont été testes, aucunes n'est bonnes , on réinitialise la case
     grille[i][j] = "0";
    //puis on retourne faux
    return false;
}
 
int main ()
{
 
    //avant tout, on donner les variable possible grâce a des info
 
     string info [25] = {"rouge","verte","jaune","bleu","blanche","anglais","espagnol","norvegien","japonais","ukrainien","eau","the","cafe","vin","lait","craven","old","kool","chesterfiel","gitane","zebre","renard","chien","cheval","escargots"};
 
    // nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on crée un info en deux dimension
    //les grille vides étant représenter par des "0"
 
    string grille[5][5] =
    {
        {"0","0","0","0","0"},// couleur
        {"0","0","0","0","0"},//nationalité
        {"0","0","0","0","0"},//boisson
        {"0","0","0","0","0"},//cigarette
        {"0","0","0","0","0"}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,info);
 
    cout<<"grille après"<<endl;
    affichage(grille);
}

j'ai remarquer que mon code tourner en boucle car des que la fonction EstValide se relance les élément mis dans mon tableau grille [5][5] sont a chaque fois les mêmes vu que cela lis ma liste [25] élément par élément
j ai donc tenter de mettre un mélangeur aléatoire sur les différente parti de ma liste ( qui contiens les couleur, les nationalité,les animaux ... )
mais cela ne change toujours rien
qui pourrais m'aider ???? car je bloque réellement la dessus

voici mon nouveau code avec le melangeur

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
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
#include <iostream>
#include <algorithm>
#include <ctime>
#include <cstdlib>
 
using namespace std;
 
 
bool positionLait( string grille[5][5],string info[25])
{
 
    //On boit du lait dans la info du milieu.
    if( !(grille[2][3]=="lait"))
        return false ;
    return true;
}
 
bool positionAnglaisRouge( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– L'Anglais habite la info rouge
        // la info0 et la info1 ne sont donc pas compatible on commence donc a la info 2
        if( (grille[i][1]=="anglais") && (grille[i][0]=="rouge") && i!=0 && i!= 1)
            return true ;
    }
    return false;
}
 
bool positionChienEspagnol( string grille[5][5],string info[25])
{
   for(int i=0;i<5;i++)
    {
        //– Le chien appartient à l'Espagnol.
        //la info 0 ne correspond pas on commence donc a la info 1
        if( (grille[i][1]=="espagnol") && (grille[i][4]=="chien") && i!=0)
            return true ;
    }
    return false;
}
 
bool positionVerteBlancheCafe( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– La info verte est à côté de la blanche, à droite.
        //– On boit du café dans la info verte.
        //la info blanche ne peut donc pas être la info 4 car la verte doit être a sa droite
        //et la info 0 ne peut pas être la blanche vu que celle a sa droite est la info bleu , donc la info verte ne peut pas être la info 1
        if((grille[i][0]=="blanche") && (grille[i+1][0]=="verte" ) && (grille[i+1][2]=="cafe") && i!=0 && i!=4 && i !=1)
            return true ;
    }
    return false;
}
 
bool positionUkrainienThe( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– L'Ukrainien boit du thé.
        if( i!=2 && i!=0 && ((grille[i][1]=="ukrainien") && (grille[i][2]=="the")))
            return true;
    }
    return false;
}
 
bool positionJauneKoolVoisinCheval( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– On fume des Kool dans la info jaune.
        //– Le fumeur de Kool habite à côté du propriétaire du cheval.
        // la info 1 n'est donc pas la bonne
        if( (grille[i][3]=="kool") && (grille[i][0]=="jaune")&& (((( grille[i+1][4]=="cheval")&& i!=4) ||((grille[i-1][4]=="cheval")&& i!=0)) && i!=1))
            return true ;
    }
    return false;
 
}
 
bool positionNorvegienAGaucheVoisinBleu( string grille[5][5],string info[25])
{
    //– Le Norvégien habite à côté de la info bleue. et le norvégien habite la première info a gauche
    // la info 0 est donc celle du norvégien et la info 1 est donc bleu
    if( (grille[0][1]=="norvegien") && (grille[1][0]=="bleu"))
        return true ;
 
    return false;
}
 
bool positionGitaneVin( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de gitanes boit du vin.
        // ce n'est pas celle du milieu vu que l on y bois du lait
        if( (grille[i][2]=="vin") && (grille[i][3]=="gitane" ) && i!=2)
            return true ;
    }
    return false;
}
 
bool positionJaponaisCraven( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le Japonais fume des Craven.
        if( (grille[i][3]=="craven") && (grille[i][1]=="japonais" ) && i!=0)
            return true ;
    }
    return false;
}
 
bool positionOldEscargots( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
         //– Le fumeur de Old Gold élève des escargots.
        if( (grille[i][4]=="escargots") && (grille[i][3]=="old"))
            return true;
    }
    return false;
}
 
bool positionChesterfieldVoisinRenard( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– Le fumeur de Chesterfield habite à côté du propriétaire du renard.
        if((grille[i][3]=="chesterfield") && (((grille[i+1][4]=="renard")&& i!=4) || ((grille[i-1][4]=="renard" )&& i!=0)))
            return true;
    }
    return false;
}
 
bool toutesConditions ( string grille[5][5],string info[25])
{
    if (!(positionLait(grille,info)) || !(positionAnglaisRouge(grille,info)) || !(positionChienEspagnol(grille,info)) || !(positionVerteBlancheCafe(grille,info)) || !(positionUkrainienThe(grille, info))||!(positionJauneKoolVoisinCheval(grille, info))||!(positionNorvegienAGaucheVoisinBleu(grille, info))||!(positionGitaneVin(grille, info))||!(positionJaponaisCraven(grille, info))||
        !(positionOldEscargots(grille,info))||!(positionChesterfieldVoisinRenard(grille,info)))
        return false;
    return true;
}
 
//fonction d affichage
void affichage ( string grille[5][5])
{
    cout<<"------------------------------"<<endl;
    for(int i=0; i<5;i++) //on lis ligne par ligne
    {
        cout<<"|";
        for(int j =0 ; j < 5; j++) //on lis colonne par colonne
        {
            cout<<"  "<<grille[i][j]<<" | "; //permet de séparer les blocs de manière vertical
        }
        cout<<endl;
        cout<<"------------------------------"<<endl;
    }
    cout<<endl;
 
}
void affiche ( string info[25])
{
 
    for(int i=0; i<25;i++) //on lis ligne par ligne
    {
        cout<<"  "<<info[i]<<endl; //permet de séparer les blocs de manière vertical
    }
    cout<<endl;
}
//nous allons avoir besoin de fonction pour tester si une valeur est bien absente d une colonne
 
bool AbsentSurBlock ( string k, string grille[5][5],int i, int j)
{
    for ( int i=0; i<5; i++)
    {
        for ( int j=0; j<5; j++)
        {
            if ( grille[i][j]==k)//si la valeur est déjà présente sur le blocs
                return false;
        }
    }
    return true;
}
 
// Prototype de la fonction
// Cette fonction va recevoir une grille en entrée et la résoudre
 
//nous devons constamment vérifier que le choix fait en amont ne provoque pas de blocage en aval
 
// on va donc utiliser le retour de la fonction pour nous indiquer si la grille est toutesConditions ou non
//enfin , comme notre fonction doit être récursive, nous allons ajouter un paramètre pour savoir quelle case nous somme en train de traiter
 
//une case (i,j) dans un info peut être représenter par un nombre (i*largeur_info)+j, que nous nommerons position
bool estValide (string grille[5][5], int position, string info[25])
{
    // si on est a la 25eme case ( on sort du info)
    if(position == 5*5)
        return true;
 
    //on récupère les coordonnées de la case
    int i = position/5, j = position%5;
 
    //si la case n'est pas vide, on passe a la suivante ( appel récursif)
    if (grille[i][j] !="0")
        return estValide(grille, (position +1), info);
 
    srand(time(NULL));
    random_shuffle(info, info+5);
 
    random_shuffle(info+5, info+10);
 
    random_shuffle(info+10, info+15);
 
    random_shuffle(info+15, info+20);
 
    random_shuffle(info+20, info+25);
 
    //énumération des valeurs possible
    for(int k = 0; k<25 ; k++)
    {
        //si la valeur est absente ,et si elle répond au contrainte
        if(AbsentSurBlock(info[k],grille,i,j))
        {
            //on enregistre dans la grille
            grille[i][j]=info[k];
            // on appelle récursivement la fonction estValide(), pour voir si ce choix est bon par la suite
            if( estValide (grille, position+1,info)&&  toutesConditions(grille,info) )
                return true; //si le choix est bon, plus la peine de continuer on renvoie true
        }
    }
 
    //toutes les valeur ont été testes, aucunes n'est bonnes , on réinitialise la case
    for(int i = 0;i<5;i++)
    {
        for (int j=0;j<5;j++)
        {
            grille[i][j] = "0";
        }
    }
    //puis on retourne faux
    return false;
}
 
int main ()
{
 
    //avant tout, on donner les variable possible grâce a des info
 
     string info [25] = {"rouge","verte","jaune","bleu","blanche","anglais","espagnol","norvegien","japonais","ukrainien","eau","the","cafe","vin","lait","craven","old","kool","chesterfiel","gitane","zebre","renard","chien","cheval","escargots"};
 
    // nous allons prendre un exemple de grille pour pouvoir tester notre code
    //on crée un info en deux dimension
    //les grille vides étant représenter par des "0"
 
    string grille[5][5] =
    {
        {"0","0","0","0","0"},// couleur
        {"0","0","0","0","0"},//nationalité
        {"0","0","0","0","0"},//boisson
        {"0","0","0","0","0"},//cigarette
        {"0","0","0","0","0"}//animaux
 
    };
 
    cout <<"grille avant"<<endl;
 
    affichage(grille);
    estValide(grille,0,info);
 
    cout<<"grille après"<<endl;
    affichage(grille);
}

**bacelar** · 27/11/2017, 14h07

sauf que j ai pas le droit d utiliser les bibliotheque disponible

Vos prof sont des crétins(ou fainéant) qui ne veulent pas mettre à jours leur cours avec des exemples tout moisi d'il y a 30 ans, minimum.
C'est la bibliothèque STANDARD, bordel, aucun compilateur ne peut être fournit sans cette bibliothèques.

Pas de classe, pas d'enum, en C++, on n'aura tout vu.

Il y a quand même beaucoup de remarques qui n'y sont pas liées et que vous n'avez toujours pas appliquées.

heuuu ? pour lait pas compris

Vos boissons, elle sont stockée dans la 3ème lignes, donc la boisson pour la maison du milieux, c'est "maison[2][2]", si vous vous planté sur un truc aussi simple, ça sent déjà pas mal le sapin.

pour le i+1 et le i-1 si tu lis la condition jusqu au bot je précise &&i!=4 && i != de 0

Bien sur que je les ait lu, mais c'est bien trop compliqué pour RIEN.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
bool positionVerteBlancheCafe( string grille[5][5],string info[25])
{
    for(int i=0;i<5;i++)
    {
        //– La info verte est à côté de la blanche, à droite.
        //– On boit du café dans la info verte.
        //la info blanche ne peut donc pas être la info 4 car la verte doit être a sa droite
        //et la info 0 ne peut pas être la blanche vu que celle a sa droite est la info bleu , donc la info verte ne peut pas être la info 1
        if((grille[i][0]=="blanche") && (grille[i+1][0]=="verte" ) && (grille[i+1][2]=="cafe") && i!=0 && i!=4 && i !=1)
            return true ;
    }
    return false;
}

Code :

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

1
2
3
4
5
6
7
8
9
bool positionVerteBlancheCafe( string grille[5][5],string info[25])
{
    for(int i=2;i<4;i++)
    {
        if((grille[i][0]=="blanche") && (grille[i+1][0]=="verte" ) && (grille[i+1][2]=="cafe"))
            return true ;
    }
    return false;
}

C'est quoi le plus simple ?
En plus vous ne devriez pas faire d'optimisation à la con.

donc la non plus je vois pas ou est le soucis vu que i est différent dans deux extrémités il ne peut pas y avoir de débordement

Les bornes des boucles, c'est fait pour ça !!!

après pour les appellation comment qu elle s'appel n'est pas vraiment important

Si vous n'avez toujours pas compris que cette phrase est une ineptie, c'est que vous n'êtes pas près pour le développement.

apres cela reste un tp mais je le change pour te faire plaisir

Pourquoi cela serait différent dans un projet des milliers de fois plus long avec des deadline ?
C'est bien pire.

pour le reste j'ai modifier le code meme si cela ne change pas grand chose au final

Si vous appliquez un peu nos conseils, vous y verriez largement plus clair.

**joe0703** · 27/11/2017, 14h21

en faite ils veulent comme tu dit que l'on recrée la roue par nous meme mais a notre façon donc ils ne veulent pas que l'on utilise les bibliothèques
après pour ce qui est des classe c'est que beaucoup commence a peine a les apprendre donc ils ne veulent pas leur rendre la taches plus dur ( a leurs sens) .
en effet pour lait je sais pas pourquoi j'y' suis suis passer a coter. je pense aussi que j'avais mal compris votre remarque ^^" .
Pour les nom de fonction mdr c'est surtout car leur sujet ne me plaise pas ptdr ^^" donc ça me prend la tête de les faire d'autant plus avec les cours qu'il nous donne qui date comme tu a pu le comprendre de Mathusalem mdr ^^ .
après en effet utiliser vos orientation m'aidera mais avant cela il me faut les comprendre vu que je ne les connait pas encore mdr. c'est le Default en programmation, la plus part des site donne des cours mais ces derniers sont souvent déjà trop pousser pour ceux qui débute en programmation je trouve et ce n'est malheureusement pas les prof qui aide beaucoup mdr depuis mon premier message mon prof ne ma répondu qu'une seule fois quand toi tu a pris la peine de me répondre déjà plusieurs fois mdr ce qui tu l’avouera est peu logique.

**bacelar** · 27/11/2017, 15h52

après pour ce qui est des classe c'est que beaucoup commence a peine a les apprendre donc ils ne veulent pas leur rendre la taches plus dur ( a leurs sens) .

Le C++ n'est pas vraiment le langage de prédilection pour apprendre la programmation.

après en effet utiliser vos orientation m'aidera mais avant cela il me faut les comprendre vu que je ne les connait pas encore mdr.

Il y en a qui ne sont pas durs à suivre.

Vous affichez la grille ligne 257, sans même vérifier que le résultat ligne 255 est "vrai".
Si le problème n'est pas soluble, vous faites quoi ?

Vos méthodes conditions font de l'optimisation prématurée, commencez par un truc qui fonctionne, puis on mesure les performances, puis on optimise.

Ligne 211, vous lancer valide sur l'ancienne grille, pas sur la "nouvelle proposition".

Votre mécanisme de récursion qui revient en arrière via "position -1" ligne 224 n'est absolument pas logique.

Faites absolument au plus simple.
Ajoutez des conditions pour ne pas mélanger les propriétés couleur/pays/boisson/cigarette/animal.

**joe0703** · 30/11/2017, 10h51

j'ai reussi a faire fonctionner le code

merci pour votre aide ^^

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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
#include <iostream>
#include <iomanip>
 
using namespace std;
 
// En ligne les caracteristiques
// En colonne les maisons
 
string Nom[5][5] = {{"rouge", "verte", "blanche", "jaune", "bleue"},
                    {"Anglais","Espagnol","Ukrainien","Norvegien","Japonais"},
                    {"chien","escargot","renard","cheval","zebre"},
                    {"cafe","the","lait","vin","eau"},
                    {"Old Gold","Kool","Chesterfield","Gitane","Craven"}};
 
enum {Couleur, Nationalite, Animal, Boisson, Cigarette};
 
enum COULEUR {rouge, verte, blanche, jaune, bleue};
enum NATIONALITE {Anglais,Espagnol,Ukrainien,Norvegien,Japonais};
enum ANIMAL {chien,escargot,renard,cheval,zebre};
enum BOISSON {cafe,the,lait,vin,eau};
enum CIGARETTE {OldGold,Kool,Chesterfield,Gitane,Craven};
 
void init(int M[5][7])
{
    int i, j;
 
    // Le tableau est plus grand pour eviter les tests de debordement
    for (i = 0;i < 5; i++)
        for (j = 0;j < 7; j++)
            if (j == 0 || j == 6)
                M[i][j] = -2;
            else
                M[i][j] = -1;
 
    // Le Norvegien habite la premiere maison a gauche
    M[Nationalite][1] = Norvegien;
 
    // On boit du lait dans la maison du milieu.
    M[Boisson][3] = lait;
 
    // Le Norvégien habite à côté de la maison bleue.
    M[Couleur][2] = bleue;
}
 
void Afficher(int M[5][7])
{
    for (int i = 0;i < 5; i++)
    {
        cout << "| ";
        for (int j = 1;j < 6; j++)
        {
            if (M[i][j] == -1)
                cout << setw(12) << 'x' << " | ";
            else
                cout << setw(12) << Nom[i][ M[i][j] ] << " | ";
        }
        cout << endl;
    }
    cout << endl;
}
 
bool existe(int M[5][7], int c, int vc, int & i)
{
    for (i = 1;i < 6; i++)
        if (M[c][i] == vc)
            return true;
    return false;
}
 
bool acceptable(int M[5][7], int m, int c)
{
    int p;
 
    // La dernière caractéristique placée doit etre unique
    for (p = 1;p < 6; p++)
        if (p != c && M[m][p] == M[m][c])
            return false;
 
    // Les contraintes "en dur"
 
    // L'Anglais habite la maison rouge.
    if (existe(M, Couleur, rouge, p)
        && M[Nationalite][p] != -1
        && M[Nationalite][p] != Anglais)
            return false;
    // Le chien appartient à l'Espagnol.
    if (existe(M, Nationalite, Espagnol, p)
        && M[Animal][p] != -1
        && M[Animal][p] != chien)
            return false;
    // On boit du café dans la maison verte.
    if (existe(M, Couleur, verte, p)
        && M[Boisson][p] != -1
        && M[Boisson][p] != cafe)
            return false;
    // L'Ukrainien boit du thé.
    if (existe(M, Nationalite, Ukrainien, p)
        && M[Boisson][p] != -1
        && M[Boisson][p] != the)
            return false;
    // La maison verte est à côté de la blanche, à droite.
    if (existe(M, Couleur, verte, p)
        && M[Couleur][p - 1] != -1
        && M[Couleur][p - 1] != blanche)
            return false;
    // Le fumeur de Old Gold élève des escargots.
    if (existe(M, Animal, escargot, p)
        && M[Cigarette][p] != -1
        && M[Cigarette][p] != OldGold)
            return false;
    // On fume des Kool dans la maison jaune.
    if (existe(M, Couleur, jaune, p)
        && M[Cigarette][p] != -1
        && M[Cigarette][p] != Kool)
            return false;
    // Le fumeur de Chesterfield habite à côté du propriétaire du renard.
    if (existe(M, Animal, renard, p)
        && M[Cigarette][p + 1] != -1
        && M[Cigarette][p + 1] != Chesterfield
        && M[Cigarette][p - 1] != -1
        && M[Cigarette][p - 1] != Chesterfield)
            return false;
    // Le fumeur de Kool habite à côté du propriétaire du cheval.
    if (existe(M, Animal, cheval, p)
        && M[Cigarette][p + 1] != -1
        && M[Cigarette][p + 1] != Kool
        && M[Cigarette][p - 1] != -1
        && M[Cigarette][p - 1] != Kool)
            return false;
    // Le fumeur de gitanes boit du vin.
    if (existe(M, Boisson, vin, p)
        && M[Cigarette][p] != -1
        && M[Cigarette][p] != Gitane)
            return false;
    // Le Japonais fume des Craven.
    if (existe(M, Nationalite, Japonais, p)
        && M[Cigarette][p] != -1
        && M[Cigarette][p] != Craven)
            return false;
    return true;
}
 
void avancer(int & m, int & c)
{
    c++;
    if (c == 6)
    {
        c = 1; m++;
    }
}
 
void chercher(int M[5][7], int m, int c)
{
    int v;
 
    if (m * c == 20)
        { cout << "Solution : " << endl; Afficher(M);}
    else
    {
        while (m * c <= 20 && M[m][c] != -1)
        {
            avancer(m, c);
        }
        for (v = 0;v < 5; v++)
        {
            M[m][c] = v;
            if (acceptable(M, m, c))
                chercher(M, m, c);
            M[m][c] = -1;
        }
    }
}
 
int main()
{
    int M[5][7];
    int N;
 
    init(M);
 
    chercher(M, 0, 1);
}

problème erreur a la compilation

C++

Discussions similaires

Partager

Partager