Discussion :

[kouack]

Bonjour a tous,

j'ai une map map<string,int > mymap que j'ai rempli avec les mots d'un fichier et j'aimerai interdire l'enregistrement dans le map des mots qui ne sont pas uniques comme ceci :

map<string, int>::size_type size;

map<string,int > mymap;
{
while(getline(fichier,line)){
...
size=mymap.count(mot);
if(count>=1) mymap.erase(mot);
else mymap.insert(make_pair(mot,position));
...
}//fin while

}
toutefois j'ai des problemes pour le premier getline vu que il y'aura pas encore de mot dans le map et donc il enleverra les suivants mots identiques mais pas la premiere ligne ! comment dois-je faire?
merci d'avance

[kouack]

j'ajoutes les mots et sa position dans le map au fure et a mesure du "getline"

[JolyLoic]

Intuitivement, je ferait plutôt une map<string, vector<int> > où je mettrais toutes les positions, et ensuite, dans une seconde phase, je virerais (éventuellement, car un index ayant plusieurs références n'est pas inutile...) les éléments ayant plusieurs valeurs dans le vecteur.

Ton code ne peut pas marcher, car si le mot est présent 3 fois, la première fois, il l'ajoute, la seconde, il l'enlève, et la troisième, comme il n'a pas gardé en mémoire que c'est un mot interdit, il l'ajoute à nouveau...

[kouack]

Je vais voir comment marche le conteneur vector...
merci

[kouack]

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
map<string, vector<int> > mots;
string line;
int pos=0;
for(unsigned no_line = 0;std::getline(ifs,line);++no_line){

unsigned beg = 0;//debut mot
unsigned end = 1;//fin mot
for(unsigned no_mot=0;end < line.size();++no_mot){

for(;end < line.size() && !is_delim(line[end]);++end);

std::string mot(line,beg,end-beg);
pos=pos+beg;
if(mot.size()>=3 ){
mots.insert(make_pair(mot,pos));
}

beg = end + 1;
end = beg + 1;
}//for..line.size()
}

Puis je fais :---->

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/*On enleve les mots "non uniques" */
 
map<string,vector<int> >::const_iterator
mots_it (mots.begin()),
mots_end(mots.end());
 
for(;mots_it!=mots_end;++mots_it){
const string & mot_cur = mots_it->first;
vector<int> & nbelement = mots_it->second;
if((nbelement.size())>1) mots.erase(mots_it);
}
ifs.close();

mais il y'a un bug :
invalid initialization of reference of type 'std::vector<int, std::allocator<int> >&' from expression of type 'const std::vector<int, std::allocator<int> >'

je ne sais pas pourquoi???

[JolyLoic]

Je n'ai pas le temps de tout relire...

A priori :

Pour ajouter des données dans la map, un simple :

Code :

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

mots[mot].push_back(pos);

Devrait suffire.

Pour enlever les éléments dans la map, le fait d'effacer un itérateur l'invalide, et on ne peut plus faire ++ dessus. Il faut donc faire ++ avant d'effacer.

[NiamorH]

Heu il suffit pas de faire :

Code :

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

mots[ unMot ] = unInt;

Logiquement, si unMot n'existe pas, il est créé et si il existe, sa valeur associée est mise à jour, ce n'est pas ce que tu veux ?

[kouack]

Non je veux enregistrer que les mots uniques dans le map !

[JolyLoic]

J'ai l'impression qu'il veut au final faire disparaitre les mots référencés plusieurs fois. Ta solution garderait la dernière référence trouvée dans le cas de références multiples.

[NiamorH]

Ok.
Ben t'as plein de solutions. Notamment celle là :

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
#include <algorithm>
#include <set>
#include <map>
#include <string>
 
using namespace std;
 
char* ListeMots[] = { "Bonjour",
                      "Salut",
                      "Hello",
                      "Hi",
                      "Bonjour",
                      "Coucou",
                      "Hello" };
 
 
struct Remplir
{
  Remplir( map<string, int> & tousLesMots,
           set<string>      & doublons )
    : m_map( tousLesMots ),
      m_set( doublons )
  {
  }
 
  template <typename T>
  void operator() ( T const & mot ) const
  {
    // Mot existant
    if ( m_map.find( mot ) != m_map.end() )
      m_set.insert( mot );
    else
      m_map[ mot ] = 'int '; // ou ce que tu veux
  }
 
private:
  map<string, int> & m_map;
  set<string>      & m_set;
};
 
 
struct Supprimer
{
  Supprimer( map<string, int> & tousLesMots )
    : m_map( tousLesMots )
  {
  }
 
  template <typename T>
  void operator() ( T const & mot ) const
  {
    m_map.erase( mot );
  }
 
private:
  map<string, int> & m_map;
};
 
 
int main()
{
  map<string, int> motsUniques;
  set<string>      doublons;
 
  // Ajoute tous les mots de la liste dans la map et trouve les doublons
  for_each( ListeMots, ListeMots + sizeof(ListeMots)/sizeof(char**),
            Remplir( motsUniques, doublons ) );
 
  // Supprime de la map les doublons du set
  for_each( doublons.begin(), doublons.end(),
            Supprimer( motsUniques ) );
 
  return 0;
}

[kouack]

merci . Comment je pourrai remplir la liste depuis un fichier passer en argument
dans la liste avec egalement l'enregistrement de la position du mot par rapport au debut du fichier ?

int main(int argc, char *argv[])
{
char* ListeMots[] = ??



merci

[kouack]

voila tout le code que j'avais entammé

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
#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <set>
 
inline bool is_delim(char c){
 return !isalpha(c);
 }
/***********************main**************************************/
int main(int argc, char *argv[]){
 
    const char *filename = argv[1];
    const char *filename2 = argv[2];
    std::ifstream ifs(argv[1]);
    std::ifstream if2s(argv[2]);
 
    map<string, vector<int> > mots;
           string line;
           unsigned pos=0; 
 for(unsigned no_line = 0;std::getline(ifs,line);++no_line){
 
            unsigned beg = 0;
            unsigned end = 1;
            for(unsigned no_mot=0;end < line.size();++no_mot){
 
                for(;end < line.size() && !is_delim(line[end]);++end);
 
                std::string mot(line,beg,end-beg);//recuperation du mot
                pos=pos+beg;  
                if(mot.size()>=3 ){
                std::cout << "\tajoute le mot[" << mot << "]position = " 
                << pos  << std::endl;
 
                mots[mot].insert(pos);
               }
 
                beg = end + 1;
                end = beg + 1;
            }       
        }
 
 
/*On enleve les doublons*/
 
map<string,vector<int> >::iterator
            mots_it (mots.begin()),
            mots_end(mots.end());
        for(;mots_it!=mots_end;++mots_it){
             const std::string & mot_cur = mots_it->first;
             vector<int> &nbelement = mots_it->second;
             if((nbelement.size())>1) mots.erase(mots_it);
            }
    ifs.close();
 
    return 0;    
 
}//main

[corrector]

j'ai une map map<string,int > mymap que j'ai rempli avec les mots d'un fichier et j'aimerai interdire l'enregistrement dans le map des mots qui ne sont pas uniques

Ta description n'est pas très claire.

map<string, int>::size_type size;

Bof. Mets juste :

size_t size;

map<string,int > mymap;
{
while(getline(fichier,line)){
...
size=mymap.count(mot);
if(count>=1)

Par définition, une clef est présente au plus une fois dans une map.

Donc count vaut 0 ou 1.

[kouack]

Regarde Si j'utilise un count(mot) :
en premier count(mot) == 0 mot enregistré
en second count(mot) ==1 nouveau mot non enregistré
en troisieme count(mot) == 0 mot enregistré

Donc ca ne marche qu'1 fois sur 3 (au second)
Moi je voudrai qu'il l'efface completement

[corrector]

Donc ca ne marche qu'1 fois sur 3 (au second)
Moi je voudrai qu'il l'efface completement

Peux-tu faire un effort pour définir clairement ce que "ça" doit faire? Du genre : à la fin, la map doit contenir l'ensemble des ...

Ce serait plus utile que de poster des tentatives de solutions en C++. Parce que là plusieurs personnes essaient de deviner ce tu veux faire.

[NiamorH]

A priori JolyLoic à mis le doigt sur le résultat attendu.

J'ai modifié mon premier code pour qu'il aille chercher les mots et les int dans un fichier texte formaté comme cela (j'ai fait une supposition ici, à toi d'adapter selon le fichier que tu as) :

Bonjour;256
Salut;456
Hello;987
Hi;123
Bonjour;654
Coucou;789
Hello;789

et le code donc :

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
#include <algorithm>
#include <sstream>
#include <set>
#include <map>
#include <string>
#include <fstream>
 
using namespace std;
 
// Foncteur qui, à partir d'une ligne, remplit la map et le set
// Formatage supposé de la ligne : "mot;123"
struct Remplir
{
  Remplir( map<string, int> & tousLesMots,
    set<string>      & doublons )
    : m_map( tousLesMots ),
    m_set( doublons )
  {
  }
 
  template <typename T>
    void operator() ( T const & constligne ) const
  {
    string ligne( constligne );
    istringstream iss( ligne );
    string mot;
 
    getline( iss, mot, ';' );
    int i;
    iss >> i;
 
    // Mot existant
    if ( m_map.find( mot ) != m_map.end() )
      m_set.insert( mot );
    else
      m_map[ mot ] = i;
  }
 
private:
  map<string, int> & m_map;
  set<string>      & m_set;
};
 
 
// Foncteur qui supprime un mot d'une map
struct Supprimer
{
  Supprimer( map<string, int> & tousLesMots )
    : m_map( tousLesMots )
  {
  }
 
  template <typename T>
    void operator() ( T const & mot ) const
  {
    m_map.erase( mot );
  }
 
private:
  map<string, int> & m_map;
};
 
 
int main()
{
  ifstream file( "C:\\test.txt" );
 
  map<string, int> motsUniques;
  set<string>      doublons;
 
  // Ajoute tous les mots de la liste dans la map et trouve les doublons
  for_each( istream_iterator<string>(file), istream_iterator<string>(),
    Remplir( motsUniques, doublons ) );
 
  // Supprime de la map les doublons du set
  for_each( doublons.begin(), doublons.end(),
    Supprimer( motsUniques ) );
 
  return 0;
}

Après exécution, je n'ai plus que 3 mots dans ma map : "Salut" "Hi" "Coucou" avec les entiers associés.

Ca répond à ton problème ?

[kouack]

Rappel :
le but est de lire un fichier passer en parametre, d'extraire les mots de plus de caracteres et de les enregistrer avec leur position lorsqu'ils sont des mots uniques

Pour le moment j'ai :

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <set>

inline bool is_delim(char c){
return !isalpha(c);
}
/***********************main*****************************/
int main(int argc, char *argv[]){

const char *filename = argv[1];

//Lecture du fichier
std::ifstream ifs(argv[1]);

/*declaration du map avec comme clé le mot lu et comme valeur ses
*positions dans le fichier
*exemple : mot=bicyclette pos = 4
* ...mot=velo pos = 14
* ...mot=bicyclette pos = 154...*/

map<string, vector<int> > mots;
string line;
unsigned pos=0;
for(unsigned no_line = 0;std::getline(ifs,line);++no_line){

unsigned beg = 0;
unsigned end = 1;
for(unsigned no_mot=0;end < line.size();++no_mot){

for(;end < line.size() && !is_delim(line[end]);++end);

std::string mot(line,beg,end-beg);//recuperation du mot
pos=pos+beg;
if(mot.size()>=3 ){
std::cout << "\tajoute le mot[" << mot << "]position = "
<< pos << std::endl;

mots[mot].insert(pos);
}

beg = end + 1;
end = beg + 1;
}
}

Puis----->
/*On enleve les doublons*/
//je declare un iterateur sur le map pour rechercher les mots avec plusieurs
//positions dans le fichier

map<string,vector<int> >::iterator
mots_it (mots.begin()),
mots_end(mots.end());
for(;mots_it!=mots_end;++mots_it){
const std::string & mot_cur = mots_it->first;
vector<int> &nbelement = mots_it->second;
//si le mot a plus d'1 position je l'enleve de la map
if((nbelement.size())>1) mots.erase(mots_it);

}//tant qu'on n'a pas atteint la fin du map
ifs.close();

return 0;

}//main

J'espere que cette fois j'ai été clair?

[corrector]

Rappel :
le but est de lire un fichier passer en parametre, d'extraire les mots de plus de caracteres et de les enregistrer avec leur position lorsqu'ils sont des mots uniques
[...]
J'espere que cette fois j'ai été clair?

Non.

[kouack]

// Supprime de la map les doublons du set
for_each( doublons.begin(), doublons.end(),
Supprimer( motsUniques ) );

j'arrive pas a te suivre et il y'a une erreur :
`istream_iterator' undeclared (first use this function)

[NiamorH]

Revérifie les inclusions, sous Comeau online et Visual C++ 6 ça passe :

Code :

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

1
2
3
4
5
6
#include <algorithm>
#include <sstream>
#include <set>
#include <map>
#include <string>
#include <fstream>

Pour la suppressions des doublons c'est simple : le set contient tous les doublons. On parcoure donc les éléments du set (avec for_each), en appelant pour chaque élément le foncteur Supprimer. On passe la map qui contient tous les mots dans le constructeur du foncteur Supprimer.
Le foncteur se charge de supprimer de la map chaque élément du set quon lui passe. C'est tout.