Discussion :

[kouack]

Bon peut etre que je m'exprime mal je réessais:

1-on lit un fichier quelconque passer en parametre
2-on repere tous les mots de plus de 3 caracteres
avec leur position par rapport au debut du fchier(on enregistre le couple(mot,positions))

puis :

si un mot est enregistré plusieurs fois (ici dans le map) on supprime le mot
ainsi que ses semblables

jusqu'a ce qu'on est que des mots "uniques"

[corrector]

Bon peut etre que je m'exprime mal je réessais:

C'est mieux.

Mais tu pourrais indenter ton code quand même : 3 boucles imbriquées, sans indentation, c'est pas super.

[kouack]

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

J'utilises dev-c++ 4.9.9.2 parce que ca prends pas bcp de place et j'arrive a travailler avec depuis ma clé usb!

toutefois il veut pas de la ligne
for_each( istream_iterator<string>(file), istream_iterator<string>(),
??

[corrector]

J'utilises dev-c++ 4.9.9.2 parce que ca prends pas bcp de place et j'arrive a travailler avec depuis ma clé usb!

Oui, et alors?

toutefois il veut pas de la ligne
for_each( istream_iterator<string>(file), istream_iterator<string>(),
??

Et bien recherche dans ta doc C++ ce qu'est istream_iterator et quel #include il faut mettre!

Même google te donnera la réponse!

Pour l'instant j'ai l'impression que tu fais moins d'efforts que les personnes qui essaient de t'aider.

[kouack]

Pour l'instant j'ai l'impression que tu fais moins d'efforts que les personnes qui essaient de t'aider.

Non je ne penses pas je t'expliques :
On nous demande de faire ce tp en c++ (intervalle de 2 semaines)alors que on en jamais fait.
En cours on fait que du java et un peu de c.
On ne passe pas comme ca de java a c++ il ya bcp de differences entre eux c'est pourquoi "je rames" mais je reste pas passif!.

[NiamorH]

Et bien recherche dans ta doc C++ ce qu'est istream_iterator et quel #include il faut mettre!

Même google te donnera la réponse!

Pour l'instant j'ai l'impression que tu fais moins d'efforts que les personnes qui essaient de t'aider.

c'est vrai que c'est l'impression que ça donne. Mais bon en même temps ça me permet de me familiariser et de m'entrainer avec les algos stl.

C'est

Code :

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

#include <iterator>

Qu'il te manque je pense. Dans mon implémentation, il doit être inclut ailleurs et pas dans la tienne.

Si tu ajoutes une contrainte sur le nombre de caractère minimum il faudra faire un test avant d'ajouter dans la map.

J'ai pas trop compris comment était foutu ton fichier.
Peux-tu montrer un bout du fichier tel qu'il est stp (quelques lignes) ?
Les positions sont-elles a calculer ou sont-elles stockées a coté des mots?

[kouack]

Les positions sont-elles a calculer ou sont-elles stockées a coté des mots?

Les positions sont calculées !

[kouack]

Peux-tu montrer un bout du fichier tel qu'il est stp (quelques lignes) ?

Fichier velo.txt

Une bicyclette (aussi appelée un vélo ou bicycle en langage familier au Québec)
est un véhicule terrestre composé de deux roues (d'où elle tire son nom) alignées .
La force motrice est fournie par un humain (le cycliste) en position assise ou couchée,
par l'intermédiaire de pédales. La bicyclette est l'un des principaux moyens de transport
dans de nombreuses parties du monde. Sa pratique, le cyclisme, constitue
à la fois un usage quotidien,
un loisir populaire et un sport.

[kouack]

J'avais fait un truc comme ceci :

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <stdlib.h>
#include <vector>


using namespace std;



inline bool is_delim(char c){
return !isalpha(c);
}

/****main***********************************/

int main(int argc, char *argv[]){
const char *filename = argv[1];
ifstream ifs(argv[1]);

if(!ifs){
cerr << "impossible d'ouvrir " << filename << endl;
return 1;}


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);
pos=pos+beg;

if(mot.size()>=3 ){
std::cout << "\tajoute le mot[" << mot << "]position = "
<< pos << std::endl;

mots[mot].push_back(pos);

}//if(mot.size()>=3)

beg = end + 1;
end = beg + 1;
}//..line.size()
}//getline(ifs,line)

/*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 string & mot_cur = mots_it->first;
vector<int> &nbelement = mots_it->second;
if((nbelement.size())>1) mots.erase(mot_cur);

}

ifs.close();



return 0;

}/***************main***********************************/

[corrector]

Non je ne penses pas je t'expliques :
On nous demande de faire ce tp en c++ (intervalle de 2 semaines)alors que on en jamais fait.

Justement, en étant précis dans tes questions tu aura de meilleures réponses plus rapidement.

On ne passe pas comme ca de java a c++

Certes!

c'est pourquoi "je rames" mais je reste pas passif!.

Si tu cherches istream_iterator dans google, la première réponse te dit quel #include utiliser et à quoi sert istream_iterator.

Mais bon, si tu débutes complètement, je pense qu'istream_iterator fait appel à trop de notions avancées (itérateur, algorithme - dans le sens de #include <algorithm> -, foncteur = "objet fonctionnel"), notions non indispensables pour résoudre ton problème.

[kouack]

l'insertion du mot et de la position se passe bien
mais c'est la partie ("On enleve les doublons") qui marche pas bien !

[corrector]

J'avais fait un truc comme ceci :

Si tu n'utilises pas la balise CODE :

[CODE]code ici[/CODE]

on ne vois pas l'indentation de ton programme.

Ceci dit, je sais pas si on perd grand chose.

Un indice :

Code :

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

1
2
3
4
5
6
7
int fun (int i) {
    blah
    if (blah) {
        blah blah blah
    }
    /* ici on revient au niveau du premier blah */
}

[kouack]

Si tu n'utilises pas la balise CODE :

[CODE]code ici[/CODE]

on ne vois pas l'indentation de ton programme.]

Désolé

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 <iostream>
#include <fstream>
#include <string>
#include <map>
#include <stdlib.h>
#include <vector>
 
 
using namespace std;
 
 
 
inline bool is_delim(char c){
return !isalpha(c);
}
 
/****main***********************************/
 
int main(int argc, char *argv[]){
const char *filename = argv[1];
ifstream ifs(argv[1]);
 
if(!ifs){
cerr << "impossible d'ouvrir " << filename << endl;
return 1;}
 
 
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);
pos=pos+beg; 
 
if(mot.size()>=3 ){
std::cout << "\tajoute le mot[" << mot << "]position = " 
<< pos << std::endl;
 
mots[mot].push_back(pos);
 
}//if(mot.size()>=3)
 
beg = end + 1;
end = beg + 1;
}//..line.size() 
}//getline(ifs,line)
 
/*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 string & mot_cur = mots_it->first;
vector<int> &nbelement = mots_it->second;
if((nbelement.size())>1) mots.erase(mot_cur);
 
}
 
ifs.close();
 
 
 
return 0; 
 
}/***************main***********************************/

[NiamorH]

Comment sont calculées les positions ? Je veux dire par là : les mots de moins de trois caractères comptent-ils pour une position ou sont-ils retirés du décompte ? Les mots doublons sont ils retirés du décompte ? Comment doivent être considérés les mots composés comme "c'est", "d'où" etc.

[kouack]

Comment sont calculées les positions ? Je veux dire par là : les mots de moins de trois caractères comptent-ils pour une position ou sont-ils retirés du décompte ? Les mots doublons sont ils retirés du décompte ? Comment doivent être considérés les mots composés comme "c'est", "d'où" etc.

La position c'est par rapport au debut du fichier donc chaque mot a une position (meme les doublons) !

les séparateur etant : espace ,(,),[,] .
Merci

[kouack]

Pas besoin de retirer la position des doublons du decomptes meme s'ils sont destinés a etre enlever du map!
Merci

[kouack]

En gros position = nombre de caractere lu avant le mot m.

[NiamorH]

Ok voilà un bout de code que tu peux tester (essayé avec ton fichier en entrée) :

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
#include <algorithm>
#include <sstream>
#include <set>
#include <map>
#include <string>
#include <fstream>
#include <iterator>
#include <iostream>
 
 
using namespace std;
 
 
// Outil de traitement de mots qui retire les séparateurs
struct RetireSeparateurs
{
  string Traiter( string const & mot, string const & separateurs ) const
  {
    string motRetour( mot );
 
    // Pour chaque lettre du mot
    for ( size_t i = 0; i < motRetour.size(); ++i )
    {
      // La lettre est un séparateur
      if ( separateurs.find( motRetour[i] ) != string::npos )
      {
        motRetour.erase( i );
        --i;
      }
    }
 
    return motRetour;
  }
};
 
 
// Prédicat indiquant si un mot répond au critère : plus de trois caractère
struct PlusDeTroisCaracteres
{
  bool Verifier( string const & mot ) const
  {
    return mot.size() > 3;
  }
};
 
 
// Foncteur qui, à partir d'un mot, remplit la map et le set
template <typename TRAITEMENT,
          typename CRITEREAJOUT>
struct Remplir
{
  Remplir( map<string, int> & tousLesMots,
           set<string>      & doublons,
           string const     & sep )
    : m_map( tousLesMots ),
      m_set( doublons ),
      m_sep( sep ),
      m_pos( 0 )
  {
  }
 
  template <typename T>
  void operator() ( T const & constmot )
  {
    // Obtient un nouveau mot débarassé des séparateurs
    string mot( TRAITEMENT().Traiter( constmot, m_sep ) );
 
    // Un séparateur isolé ?
    if ( mot.empty() )
      return;
 
    // Le mot est bien réél, on incrémente la position
    ++m_pos;
 
    // Le mot répond-t-il aux critères ?
    if ( !CRITEREAJOUT().Verifier( mot ) )
      return;
 
    // Le mot existe-t-il déjà ?
    if ( m_map.find( mot ) != m_map.end() )
      // Un doublon détecté
      m_set.insert( mot );
    else
      // Un nouveau mot, on stocke sa position
      m_map[ mot ] = m_pos;
  }
 
private:
  map<string, int> & m_map;
  set<string>      & m_set;
  string const     & m_sep;
  int                m_pos;
};
 
 
// 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()
{
  // Ouverture du bon fichier
  ifstream file( "C:\\test.txt" );
 
  // Map qui va au FINAL contenir les mots uniques
  // de plus de 3 carac avec leur position
  map<string, int> motsUniques;
 
  // Set intermédiaire des mots doublons
  // Sert à retirer (après coup) les doublons de la map
  set<string>      doublons;
 
  // Chaine contenant les caractère a ne pas prendre en compte
  // On pourrait plutot utiliser un Set pour plus de rapidité
  string           separateurs("()[].,'");
 
  // Itere chaque "mot" du fichier
  // (séparés par des espaces ou des sauts de ligne)
  // Insère les mots dans la map selon un critère
  // après traitement préalable et trouve les doublons
  for_each( istream_iterator<string>(file), istream_iterator<string>(),
            Remplir<RetireSeparateurs,PlusDeTroisCaracteres>( motsUniques, doublons, separateurs ) );
 
  // Supprime de la map les doublons contenus dans le Set
  for_each( doublons.begin(), doublons.end(),
            Supprimer( motsUniques ) );
 
  // Ecriture du résultat
  ofstream outfile( "C:\\out.txt" );
 
  for ( map<string, int>::iterator it = motsUniques.begin(); it != motsUniques.end(); ++it )
    outfile << it->first << " " << it->second << endl;
 
  return 0;
}

Québec 12
alignées 25
appelée 3
assise 37
bicycle 7
composé 17
constitue 63
couchée 39
cyclisme 62
cycliste 34
dans 53
deux 19
elle 21
familier 10
fois 66
force 27
fournie 30
humain 33
langage 9
loisir 71
monde 58
motrice 28
moyens 50
nombreuses 55
parties 56
populaire 72
position 36
pratique 60
principaux 49
pédales 43
quotidien 69
roues 20
sport 75
terrestre 16
tire 22
transport 52
usage 68
véhicule 15
vélo 5

La liste est triée car c'est le comportement habituel de la map. Le Québec est devant car il contient une majuscule. Tu peut y remédier en utilisant une classe string spécialisée, non sensible a la casse (faq).

Si tu préfères afficher selon la position, tu peut réinsérer les données dans une autre map avec comme clef la position, ou utiliser des le départ un vecteur (l'ordre d'insertion conservera l'ordre des positions.)

[corrector]

Si tu n'utilises pas la balise CODE :

[CODE]code ici[/CODE]

on ne vois pas l'indentation de ton programme.

Un indice :

Code :

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

1
2
3
4
5
6
7
int fun (int i) {
    blah
    if (blah) {
        blah blah blah
    }
    /* ici on revient au niveau du premier blah */
}

Désolé

Si ton programme n'est pas indenté, on ne peux pas voir l'indentation (qui n'existe pas) non plus.

Au fait, comprends-tu ce qu'est l'indentation?

[kouack]

j'ai :
ifstream file( "D:\Dev-Cpp\test.txt" );
ofstream outfile( "D:\Dev-Cpp\Projet\out.txt" );

erreurs :
D:\Dev-Cpp\Untitled2.cpp [Warning] unknown escape sequence '\P'
D:\Dev-Cpp\Untitled2.cpp [Warning] unknown escape sequence '\D'

merci