471,584 Members | 1,620 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,584 software developers and data experts.

Words Words

Dear all,

I am trying to count the occurence of words in an input stream I can
keep my words in a vector<string> as below;

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

int main(){
vector<string> str;
vector<string>::size_type sz;
string x;
while(cin >> x){
str.push_back(x);
}
sz=str.size();
for(vector<string>::size_type i=0; i!=sz; i++){
cout << str[i] << endl;
}
return 0;
}

Now I think that sorting and finding the occurences are easier so sort
them alphabetically and then find the occurences. But the occurences
causing problems in the algorithms I try on paper. Please DO NOT USE
LISTS, VECTOR.ERASE(), ITERATORS IN THE PROBABLE SOLUTIONS.
Can someone give me any ideas on this?

Thx.

Feb 16 '06 #1
6 1379
utab wrote:
Dear all,

I am trying to count the occurence of words in an input stream I can
keep my words in a vector<string> as below;

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

int main(){
vector<string> str;
vector<string>::size_type sz;
string x;
while(cin >> x){
str.push_back(x);
}
sz=str.size();
for(vector<string>::size_type i=0; i!=sz; i++){
cout << str[i] << endl;
}
return 0;
}

Now I think that sorting and finding the occurences are easier so sort
them alphabetically and then find the occurences. But the occurences
causing problems in the algorithms I try on paper.
I would use std::map<std::string, int> instead of a vector.
Please DO NOT USE LISTS, VECTOR.ERASE(), ITERATORS IN THE PROBABLE
SOLUTIONS.


Why not?

Feb 16 '06 #2
In article <11**********************@o13g2000cwo.googlegroups .com>,
"utab" <um********@gmail.com> wrote:
Dear all,

I am trying to count the occurence of words in an input stream I can
keep my words in a vector<string> as below;

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

int main(){
vector<string> str;
vector<string>::size_type sz;
string x;
while(cin >> x){
str.push_back(x);
}
sz=str.size();
for(vector<string>::size_type i=0; i!=sz; i++){
cout << str[i] << endl;
}
return 0;
}

Now I think that sorting and finding the occurences are easier so sort
them alphabetically and then find the occurences. But the occurences
causing problems in the algorithms I try on paper. Please DO NOT USE
LISTS, VECTOR.ERASE(), ITERATORS IN THE PROBABLE SOLUTIONS.
Can someone give me any ideas on this?

Thx.


Try using a std::map instead, and check out the bottom of my response to
you in the "occurence problem" thread.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.
Feb 16 '06 #3
I am following a book and I have not covered map yet. I asked a close
friend also he recommended map. But I first would like to find the
answer this way. If can't then dive into map.

thanks for the quick replies

Feb 16 '06 #4
In article <11**********************@o13g2000cwo.googlegroups .com>,
"utab" <um********@gmail.com> wrote:
Dear all,

I am trying to count the occurence of words in an input stream I can
keep my words in a vector<string> as below;

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

int main(){
vector<string> str;
vector<string>::size_type sz;
string x;
while(cin >> x){
str.push_back(x);
Don't load every word into the string, only unique words. (ie: if x not
in str, push_back x.

Once you do the above, post your code and I'll help you more.
}
sz=str.size();
for(vector<string>::size_type i=0; i!=sz; i++){
cout << str[i] << endl;
}
return 0;
}

Now I think that sorting and finding the occurences are easier so sort
them alphabetically and then find the occurences. But the occurences
causing problems in the algorithms I try on paper. Please DO NOT USE
LISTS, VECTOR.ERASE(), ITERATORS IN THE PROBABLE SOLUTIONS.
Can someone give me any ideas on this?

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.
Feb 16 '06 #5
How to control that is not that easier to sort and apply. I am now
trying that but still problems with the algoritm I have created two
more vectors. One holding the words and the other holding the repeat
times corresponding to the words. Code is wrong but I am sending it
anyway. I think you will understand what I try to do

Thx,

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

bool compare(const string & str1 ,const string & str2 ){

return str1 < str2;

}

void count(const vector<string> & S, vector<string> & ss,vector<int>
&nn){

int cnt=1;
vector<string>::size_type i=0;
string compare(S[i]);
// problems with this while loop

while(i != S.size()){

if(S[i+1]==compare)
cnt++;
else{
compare=S[i+1];
if(S[i+1]==compare)
cnt++;
}
ss.push_back(compare);
nn.push_back(cnt);
i++;
}

}

int main(){

vector<string> str;
vector<string>::size_type sz;
vector<string> s;
vector<int> n;

string x;

while(cin >> x){

str.push_back(x);

}

sz=str.size();

for(vector<string>::size_type i=0; i!=sz; i++){

cout << str[i] << endl;

}

sort(str.begin(),str.end(),compare);

for(vector<string>::size_type i=0; i!=sz; i++){

cout << str[i] << endl;

}
count(str,s,n);

for(vector<string>::size_type i=0; i!=sz; i++){

cout << s[i] << ' ' << n[i] << endl;

}

return 0;
}

Feb 16 '06 #6
In article <11**********************@o13g2000cwo.googlegroups .com>,
"utab" <um********@gmail.com> wrote:
How to control that is not that easier to sort and apply.
No, it isn't easer.
I am now
trying that but still problems with the algoritm I have created two
more vectors. One holding the words and the other holding the repeat
times corresponding to the words. Code is wrong but I am sending it
anyway. I think you will understand what I try to do


You need to start smaller, and work your way up. Paste the code below
into your cpp file (overwrite what you have) and then run the program.
What you are supposed to see is "working" what you will actually see is
some error message. Put code in the "insert your code here" spot and
keep running the program until you can get "working" to appear on the
screen. Once you do that, I'll take you to the next step.

@begin code

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>
#include <string>
#include <cstdlib>

using std::cout; using std::cin;
using std::vector; using std::endl;
using std::setprecision; using std::setw;
using std::max; using std::string;

void count_words( const vector<string>& S, vector<string>& ss,
vector<int>& nn )
{
// insert code here
}

int main() {
{
vector<string> in;
in.push_back( "word" );
vector<string> str;
vector<int> count;
count_words( in, str, count );
assert( str.size() == 1 );
assert( count.size() == 1 );
assert( str[0] == "word" );
assert( count[0] == 1 );
}
{
vector<string> in;
in.push_back( "word" );
in.push_back( "big" );
vector<string> str;
vector<int> count;
count_words( in, str, count );
assert( str.size() == 2 );
assert( count.size() == 2 );
assert( str[0] == "word" );
assert( count[0] == 1 );
assert( str[1] == "big" );
assert( count[1] == 1 );
}
cout << "working";
}

@end code

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.
Feb 16 '06 #7

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

9 posts views Thread by superprad | last post: by
7 posts views Thread by Sling | last post: by
7 posts views Thread by Jim Carlock | last post: by
7 posts views Thread by abraxas | last post: by
7 posts views Thread by Jay | last post: by
20 posts views Thread by dmurray14 | last post: by
reply views Thread by XIAOLAOHU | last post: by
reply views Thread by leo001 | last post: by
reply views Thread by lumer26 | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.