Discussion :

[stanfillirenfro]

Salut à tous!
Après votre soutien ans faille, j'ai pu avancer sérieusement dans la comprehension et la résolution des soucis concernant un bout de code que j'ai posté sur ce forum il y a peu.
Je reviens une fois de plus avec un problème qui me freine depuis quelques jours déjà.
Il s'agit des opérations sur un tableau à deux dimensions.
Prenons une cellule quelconque du tableau. Cette cellule peut avoir trois résultats différents venant des opérations effectuées: Par exemple: On peut décider d'ajouter une unité à la valeur de la cellule de gauche, chercher la racine carrée de celle juste au dessus ou alors diviser la valeur de la cellule diagonale précédente par un nombre impair. La suite consiste à afficher le plus grand résultat provenant de ces trois opérations. Jusqu'ici, il n'y pas de problème. Là où le code devient intéressant et malheureusement compliqué est qu'il faut ensuite indiquer de quelle direction vient ce plus grand résultat(gauche, dessus ou diagonale). Il est à noter que chaque cellule est susceptible d'avoir un plus grand résultat différent des autres cellules. Pour pouvoir, indiquer de quel sens vient le plus grand résultat, j'ai pensé à uniformiser ce plus grand résultat. c'est à dire si ce plus grand vient de la cellule de gauche, j'écris 2 par exemple. S'il vient de la cellule au dessus, j'écris 1 et s'il vient de la diagonale, j'écris 3. C'est à ce niveau que mon code dérange. À la compilation, telle que les lignes 28, 32 et 36 sont écrites, les résultats sont bons et représentent les opérations sur les cellules correspondantes. Mais en remplaçant diag par 3 par exemple à la ligne 28, left par 2 à la ligne 32 et above par 1 à la ligne 36, les cellules n'affichent plus les vraies directions. C'est à dire on obtiendrait un 2 à la place de 1 ou 1 à la place de 3, puisqu'en comparant ces directions aux vrais résultats des opération, on voit qu'il n'a pas concordance. 3 par exemple indiquerait que le plus grand résultat vient de la diagonale précédente, tandis que 2 indiquerait que le plus grand résultat viendrait de la cellule de gauche..., donc ces chiffres indiqueraient non plus le plus grand résultat, mais de quelle direction vient ce grand résultat.

Le problème donc se pose lorsque je change diag, left et above en chiffres.
Pouvez-vous s'il vous plait jeter un coup d'œil sur mon code et m'aider à contourner cette difficulté?

Je vous serai gré.

Merci d'avance.


Voici mon bout de 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
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
std::string str1 = "ABABA";
	std::string str2 = "BBBBBAAA";
        double diag, left, above;
 
	matrix<double> m (str1.size()+1, str2.size()+1);
 
 
	for(size_t i=0;i<m.size1 ();++i){m(i,0)=i;}
	for(size_t j=1;j<m.size2 ();++j){m(0,j)=j;}
 
	for(size_t i=1;i<m.size1();++i){
	for(size_t j=1;j<m.size2();++j){
		if(str1[i-1] == str2[j-1])
            {
                diag = m(i-1, j-1)+ 1;
            }
            else
            {
                diag = m(i-1, j-1);
            }
 
            left = m(i-1, j) - 1;
            above = m(i, j-1) - 1;
 
       // Ici, je choisis le plus grand résultat.
       if(diag >= left && diag >= above)
            {
                m(i, j) = diag;
            }
            else if(left >= diag && left >= above)
            {
                m(i, j) = left; 
            }
            else if(above >= diag && above >= left)
            {
                m(i, j) = above; 
            }
	}}
 
	//affichage
	std::cout<<"    ";
	for(size_t j=0;j<m.size2 ();++j){std::cout << str2[j] << " ";} std::cout << "\n";
 
	for(size_t i=0;i<m.size1 ();++i){
 
		if(i==0){		std::cout <<"  ";}
		else{std::cout << str1[i-1]<<" ";}
 
 
		for(size_t j=0;j<m.size2();++j){
			std::cout << m(i,j)<<" ";
		}
		std::cout <<"\n";
	}

[Invité]

salut,

t'es pas clair.
Ta cellule elle contient quoi. Une valeur, ou la direction de la plus grande cellule aux alentours prise parmi diag, left, above?

Car si elle contient une valeur (par exemple la plus grande des cellules aux alentours), alors par définition même, sa valeur ne correspondra pas à la direction.

Tu n'as qu'à stocker un couple valeur/direction dans chaque cellule

[stanfillirenfro]

Salut galerien69 et merci pour ta réponse.
Après les calculs, chaque cellule contient une valeur, un nombre représentant le plus grand des trois qui proviennent des opérations. Je veux stocker la plus grande valeur de diag, left et above. Cela signifie que jusqu'ici, j'ai pris une valeur sur tois. Cette valeur prise peut venir de la cellule de gauche, diagonale ou du dessus. Ici, je veux identifier la direction de laquelle vient cette grande valeur. Si la cette grande valeur vient de la diagonale, alors au lieu de la conserver, j'écris plutot le chiffre 3. Si la grande valeur vient de gauche, alor sj'écris 2.... La grande valeur d'une cellule est differente de celle de l'autre, et c'est pourquoi il faut quelque chose pour désigner toute les grande valeur.
Ton idée de stocker valeur/direction est pertinante, et je t eserai reconnaissant si tu me guidais un peu dans son implémentation. Je n'ai pas encore eu à stocker deux valeurs dans le meme cellule d'un tableau.

Merci d'avance.

[Invité]

Ben je me répète encore une fois t'es pas clair

Je veux stocker la plus grande valeur de diag, left et above....
Si la cette grande valeur vient de la diagonale, alors au lieu de la conserver.

Donc après calcul de ta grille, que dois tu connaitre pour une cellule donnée.
La valeur la plus grande de diag left et above?
La direction?
Les deux?

Je n'ai pas encore eu à stocker deux valeurs dans le meme cellule d'un tableau.

ben au pire tu fais deux tableaux. Un qui stocke la valeur, un qui stocke la direction

Sinon, tu fais une structure pair pour stocker tes deux nombres ou en réutilises une (ex: std::pair<double, size_t>, ou size_t représente la direction) et tu fais une matrice de ta pair : matrix<std::pair<double, size_t> >).

[stanfillirenfro]

Salut galerien69 et merci pour ta réponse.
Je fais trois opération differente et je stocke le plus grand résultat dans la cellule (i, j). Pour deux cellules differentes, j'aurai donc 6 résultats differents (trois par cellule) et je vais choisir chaque fois le plus grand résultats. je veux en fin de compte la direction, qui doit etre déterminée par la position de la cellule ayant donné le grand résultat.

[Invité]

je veux en fin de compte la direction, qui doit etre déterminée par la position de la cellule ayant donné le grand résultat.

ok

ben dans ce cas là tu ne peux te contenter de ne préserver que la direction.

Donc il faut que tu stocke la valeur et la direction d'une itération à l'autre.

[stanfillirenfro]

Salut galerien69 et merci pour ta réponse.
Ainsi, juste après la ligne 5, j'ai ajouté ca:

Code :

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

std::pair<double, size_t> cell;

J'ai remplacé les lignes 28, 32 et 36 respectivement par:

Code :

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

1
2
3
m(i, j) = cell(diag, 3);
m(i, j) = cell(left, 2);
m(i, j) = cell(above, 1);

,
mais à la compilation, ca me montre l'erreur:
No match for call to: "(std: pair<double, unsigned int>) (dounle&, int)".
Peux-tu s'il te plait y jeter un coup d'oeil et me dire où ca ne tient pas?
Merci d'avance.

[ternel]

Essaie std::make_pair() de <utility>
Sinon, tu peux aussi préférer une struct personnalisée, genre:

Code :

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

1
2
3
4
5
6
struct Cell{
	double direction;
	size_t value;
	Cell(double d, size_t v):direction(d), value(v){}
	Cell(const Cell& c):direction(c.direction), value(c.value){}
};

[Invité]

No match for call to: "(std: pair<double, unsigned int>) (dounle&, int)".

ben cest comme si t'ecris
string s;
s(4)
s(3)
string c'est pas une fonction.

La c'est pareil, tu devrais plutot ecrire
m(i,j)=std::pair<blabla>(diag,3)
pour faire appel au constructeur

[ternel]

ou changer typedef std::pair<double, size_t> cell;

[stanfillirenfro]

Salut!
En écrivant m(i,j)=std::pair<blabla>(diag,3), le meme message d'erreur apparait.
En ajoutant typedef dans mon constructeur, c'est à dire typedef std::pair<double, size_t> cell; il est écrit comme erreur que ma fonction ne peut pas etre convertie en double.

Je vous serai reconnaissant si vous me filiez un code amélioré, car je suis vraiment limité à ce niveau.

Merci d'avance!

[ternel]

C'est effectivement logique, si tu as encore la déclaration matrix<double> m;.
Tu dois aussi passer matrix<Cell> m;.

[stanfillirenfro]

Salut leternel:
En passant aussi matrix<Cell> m; en plus de matrix<double> m, ca ne marche pas. Deux m dans la meme fonction avec des types differents.
Peut-on faire autrement s'il vous plait?

[Bousk]

Renomme l'un des deux.

[stanfillirenfro]

Salut Bousk!
Il n'y a toujours pas de modification apres avoir renommé l'un d'eux.

[ternel]

En écrivant m(i,j)=std::pair<blabla>(diag,3), le meme message d'erreur apparait.
En ajoutant typedef dans mon constructeur, c'est à dire typedef std::pair<double, size_t> cell; il est écrit comme erreur que ma fonction ne peut pas etre convertie en double.

C'est effectivement logique, si tu as encore la déclaration matrix<double> m;.
Tu dois aussi passer matrix<Cell> m;.

Il n'y a toujours pas de modification apres avoir renommé l'un d'eux.

Avec ton code initial, dans m(i,j)=std::pair<blabla>(diag,3), m(i,j) est un double, puisque tu as matrix<double> m;, or, std::pair<...> n'est pas un double mais un cell. Il te faut changer un de ces deux types.

Si tu changes ton code pour utiliser matrix<Cell> m;, m(i,j) sera bien un Cell.
Cela implique de changer la déclaration, puis de faire les adaptations correspondantes. Au pire, il "suffit" de suivre les erreurs de compilations...

[stanfillirenfro]

Salut Leternel
J'ai préféré utliser Cell, ce qui fait que j'ai modifié de la sorte:

Code :

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

1
2
typedef std::pair<double, Direction> Cell;
matrix<Cell> m (str1.size()+1, str2.size()+1);

La ligne 8 par exemple est devenue:

Code :

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

 for(size_t i=0;i<m.size1 ();++i){m.at_element(i,0) = i;}

De la ligne 15 j'ai fait deux lignes comme suit:

Code :

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

1
2
diag = m.at_element(i-1, j-1).first;
diag += 1;

Alors ca compile vien, les les cases ont toutes les valeurs 0.
Peux-tu s'il te plait y jeter un coup d'eoil et me dire ce qui ne va pas?

[ternel]

Ca ressemble au fait que tu ne réinjecterais pas "diag" dans la case. diag est une variable autonome, donc lui donner une valeur ne la fais pas apparaître magiquement dans le tableau.

Cela dit, si tu veux plus d'aide, il nous faudrait le nouveau code.

[stanfillirenfro]

Salut Leternel et merci pour ta réponse.
Je poste un noiveau code comme demandé.
Jai modifié le code en ajoutant une énumération pour la direction comme suit:

Code :

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

1
2
3
4
enum Direction
{
    none, diago, lefto, abovo
};

Puis, le code lui même.

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
 
using namespace boost::numeric::ublas;
 
    QString str1, str2, str1al, str2al, diago, lefto, abovo;
    double diag, left, above
    str1al = "";
    str2al = "";
 
   typedef std::pair<double, Direction> Cell;
    matrix<Cell> m (str1.size()+1, str2.size()+1);
 
    out << str1<<"\r\n"<<str2<<"\r\n\r\n";
 
//    Initialiser le tableau
 
    for(size_t i=0; i<m.size1(); ++i)
    {
        m(i,0)= Cell(static_cast<float>(i)*(-1.f), none);
    }
 
    for(size_t j=1; j<m.size2(); ++j)
    {
        m(0,j)= Cell(static_cast<float>(j)*(-1.f), none);
    }
 
//    Calcul
    for(size_t i=1; i<m.size1(); ++i)
    {
        for(size_t j=1; j<m.size2() ;++j)
        {
            if(str1[i-1] == str2[j-1])
            {
                diag = m(i-1, j-1).first + 1;                
            }
            else
            {
                diag = m(i-1, j-1).first;
            }
 
            left = m(i-1, j).first - 1;
            above = m(i, j-1).first - 1;
 
           // Ici, je choisis le plus grand résultat et la direction.
            if(diag >= left && diag >= above)
            {
                m(i, j).first = diag;
                m(i, j).second = diago;                
            }
            else if(left >= diag && left >= above)
            {
                m(i, j).first = left;
                m(i, j).second = lefto;                
            }
            else if(above >= diag && above >= left)
            {
                m(i, j).first = above; 
                m(i, j).second = abovo;               
            }
         }
    }
 
    //affichage
    out<<"    ";
    for(size_t j=0; j<m.size2(); ++j)
    {
        out << str2[j] << " ";
    }
    out << "\r\n";
 
    for(size_t i=0; i<m.size1(); ++i)
    {
        if(i==0)
        {
            out <<"  ";
        }
        else
        {
            out << str1[i-1]<<" ";
        }
 
 
        for(size_t j=0; j<m.size2(); ++j)
        {
            out << m(i,j).first<<" ";
            out << m(i,j).second<<" ";
        }
        out <<"\r\n";
    }

À la compilation, j'obtiens le message d'erreur suivant pour ligne 47, 52, 57 :

erreur : cannot convert 'QString' to 'Direction' in assignment

Je te serai reconnaissant pour ton aide.
Merci d'avance.

[ternel]

Bon, ici, le problème est simple, pour peu qu'on le connaisse.
D'un coté, enum Direction{ none, diago, lefto, abovo };.
De l'autre, QString diago, lefto, abovo;.

L'identificateur "diago" désigne à la fois la QString et l'une des valeurs du type "enum Direction".

En fait, les énumérations injectent chacun de leurs membres dans le scope qui l'englobe directement.

class truc{ enum {a,b} f;}; déclare truc::a et truc::b comme deux valeurs constantes (et statiques) d'une énumération anonyme (c'est à dire, deux entiers valant 0 et 1). Il s'agit du relativement classique "enum hack".


Les QStrings déclarés dans la fonction masquent les constantes du type enum Direction. Il te faut donc utiliser Direction::diago pour se référer à la valeur de l'enum.
Mieux, d'après ton code, supprime les déclarations des QStrings diago, lefto et abovo, vu que tu ne les utilises pas.


Le moyen de se débarrasser de cette "pollution" est de déclarer un "enum class Direction{...}", mais dans ce cas, le seul accès possible est Direction::diago.


Qui plus est, je trouve que diago est un étrange choix de nom. Que signifie le o, par rapport à diag? J'aurai plus utilisé direction_diag ou diag_dir ou diag_d ou simplement diag en utilisant les scopes explicitement.


Pour ta cell, je ferai bien quelque chose du style :

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
class Cell{
	public:
		enum class Direction {none, left, diagonal, above};
	private:
		double valeur;
		Direction direction;
 
		static Direction bestDirectionOf(double left, double diag, double above)
			if(left<diag){
				return diag<above? Direction::above : Direction::diagonal;
			} else {
				return left<above? Direction::above : Direction::left;
			}
		}
 
		static double bestOf{double left, double diag, double above
			if(left<diag){
				return diag<above? above : diagonal;
			} else {
				return left<above? above : left;
			}
		}
 
	public:
		Cell() : valeur(0), direction(Direction::none) {}
		explicit Cell(float) : valeur(v), direction(Direction::none){}
 
		Cell(double left, double diag, double above) :
			valeur( bestOf(left, diag, above) ),
			direction( bestDirectionOf(left, diag, above) )
		{}
 
		double value() const {return valeur;}
		Direction direction() const {return direction;}
};
 
inline std::ostream& operator<<(std::ostream& os, Cell c) {
	out << (c.value());
	switch(c.direction()){
		case Direction::left : return out<<"  left";
		case Direction::diagonal : return out<<"  diag";
		case Direction::above : return out<<" above";
	}
	return out;
}
 
 
using namespace boost::numeric::ublas;
void f(const QString& str1, const QString& str2) {
	out << str1<<"\r\n"<<str2<<"\r\n\r\n";
 
	matrix<Cell> m (str1.size()+1, str2.size()+1);
 
//    Initialiser le tableau
 
	for(size_t i=0; i<m.size1(); ++i) m(i,0)= Cell(-i);
	for(size_t i=1; i<m.size2(); ++i) m(0,i)= Cell(-i);
 
//    Calcul
	for(size_t i=1; i<m.size1(); ++i) {
		for(size_t j=1; j<m.size2() ;++j) {
			double diag = m(i-1, j-1).value() + ( (str1[i-1]==str2[j-1])? 1 : 0);
			double left = m(i-1, j).value() - 1;
			doubleabove = m(i, j-1).value() - 1;
 
			// Ici, je choisis le plus grand résultat et la direction.
			m(i, j) = Cell(left, diag, above);
		}
	}
 
	//affichage
	out<<"    ";
	for(size_t j=0; j<m.size2(); ++j) out << str2[j] << " ";
	out << "\r\n";
 
	for(size_t i=0; i<m.size1(); ++i) {
		out <<((i==0)?' ':str1[i-1])<<' ';
		for(size_t j=0; j<m.size2(); ++j) out << m(i,j)<<' ';
		out <<"\r\n";
	}
}