problem with sort

[Gaijinco]

I'm not quite sure why this code doesn't works:

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

class word
{
string letters;
string sorted;
public:
word(string&s)
{
letters=s;
sort(s.begin(),s.end());
sorted=s;
}
friend bool lt(word& a, word& b)
{
return (a.sorted < b.sorted) < 0 ? true: false;
}
friend ostream& operator<<(ostream& out, vector<word>& v)
{
for(int i=0; i<v.size(); ++i)
cout << v.letters << endl;
return out;
}
};

int main()
{
vector<word>dict;
string aux;
cin >> aux;

while(aux!="#")
{
word w(aux);
dict.push_back(w);

cin >> aux;
}

sort(dict.begin(),dict.end(),lt);
cout << dict << endl;

return 0;
}

There's something wrong with the function "lt" but i'm not sure what.
In the prototype it says:
StrictWeakOrdering cmp but I'm not sure what does that mean, maybe
something about the kind of iterators I need to use?

Thanks!

 

[Kai-Uwe Bux]

I'm not quite sure why this code doesn't works:

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

class word
{
string letters;
string sorted;
public:
word(string&s)
{
letters=s;
sort(s.begin(),s.end());
sorted=s;
}

Are you sure, you want this constructor to have the side-effect of sorting
the parameter passed? What about:

word ( string const & s )
: letters ( s )
, sorted ( s )
{
sort( sorted.begin(), sorted.end() );
}

friend bool lt(word& a, word& b)
{
return (a.sorted < b.sorted) < 0 ? true: false;

Huh? operator< returns a bool, it is not a three-way comparison yielding an
int. What about:

return ( a.sorted < b.sorted );

}
friend ostream& operator<<(ostream& out, vector<word>& v)

This should be:

friend ostream& operator<< ( ostream& out, vector<word> const & v )

unless you want the output operator to modify its argument.

{
for(int i=0; i<v.size(); ++i)
cout << v.letters << endl;
return out;
}
};

int main()
{
vector<word>dict;
string aux;
cin >> aux;

while(aux!="#")
{
word w(aux);
dict.push_back(w);

cin >> aux;
}

sort(dict.begin(),dict.end(),lt);
cout << dict << endl;

return 0;
}

There's something wrong with the function "lt" but i'm not sure what.
In the prototype it says:
StrictWeakOrdering cmp but I'm not sure what does that mean, maybe
something about the kind of iterators I need to use?

Soring a dictionary according to the lexicographic order of internally
rearranged words seems to be a rather strange requirement. Are you sure,
your want that?


Best

Kai-Uwe Bux

 

[mlimber]

I'm not quite sure why this code doesn't works:

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

class word
{
string letters;
string sorted;
public:
word(string&s)

You should probably use a const reference here. Compare:

http://www.parashift.com/c++-faq-lite/const-correctness.html#faq-18.6

{
letters=s;

Use initialization lists. See this FAQ:

http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.6

sort(s.begin(),s.end());
sorted=s;

If you switch to a const reference (which you probably should), you'll
need to copy the unsorted parameter into "sorted" first, and then sort
it. But consider what this does: it sorts the letters within a word. So
"august" becomes "agstuu", which you then use in your compare function.
That's probably not what you want to do.

}
friend bool lt(word& a, word& b)
{
return (a.sorted < b.sorted) < 0 ? true: false;

When comparing strings, you could just do:

return a.letter < b.letter;

The other business there is unecessary and almost certainly wrong. The
< operator returns a bool, so checking if it is less than zero is
non-sensical. It's either false (zero) or true (not zero).

}
friend ostream& operator<<(ostream& out, vector<word>& v)
{
for(int i=0; i<v.size(); ++i)
cout << v.letters << endl;
return out;
}

First, you output to "cout" but then return "out", which you didn't
actually use or modify. Second, it is more customary to provide a
friend output function just for your class and then provide another
non-friend function to handle vectors of any type. In that case, your
prototype for this function would be:

friend ostream& operator<<( ostream& out, const word& w );

and the prototype for the non-friend would be:

template<class T>
ostream& operator<<( ostream& out, const vector<T>& v );

Note the const reference for v, which you don't modify.

};

int main()
{
vector<word>dict;
string aux;
cin >> aux;

while(aux!="#")
{
word w(aux);
dict.push_back(w);

cin >> aux;
}

This is the wrong way to use cin. See the example in this FAQ:

http://www.parashift.com/c++-faq-lite/input-output.html#faq-15.5

sort(dict.begin(),dict.end(),lt);
cout << dict << endl;

return 0;
}

There's something wrong with the function "lt" but i'm not sure what.

See above. The bottom line here is that you don't even need the word
class (unless you really do want to sort by "agstuu" instead of
"august"). Just make a vector of strings and sort that with the default
comparison function.

In the prototype it says:
StrictWeakOrdering cmp but I'm not sure what does that mean, maybe
something about the kind of iterators I need to use?

No. See this definition:

http://www.sgi.com/tech/stl/StrictWeakOrdering.html

Cheers! --M

 

[Andre Kostur]

I'm not quite sure why this code doesn't works:

[snip other reasonable code]

friend bool lt(word& a, word& b)
{
return (a.sorted < b.sorted) < 0 ? true: false;
}

What's the "< 0" doing in that statement? Why isn't it just:

return a.sorted < b.sorted;

? Operator< returns a bool. As it is now, the result of operator< will
never be less than 0, so lt will always return false.

[snip other reasonable code]

There's something wrong with the function "lt" but i'm not sure what. In
the prototype it says:
StrictWeakOrdering cmp but I'm not sure what does that mean, maybe
something about the kind of iterators I need to use?

Strict Weak Ordering. Your function needs to provide "less-than"
semantics (which yours attempts to do). Google for it, you'll find a
definition much better than I can give.

Although you are sorting your strings in a rather novel way... (sorting
the letters in the word first, and comparing that to order the words...

 

[Gaijinco]

A little explanation may clarify somethings:

The code was to solve a problem from acm.uva.es called Ananagrams. The
problem stated that given a text you were to find the words that didn't
have anagrams within the text (called ananagrams in the problem)

That's why there was comparations between the sorted strings, to know
if there were anagrams.

Thank you all for your opinions, they were really helpful and
insightful!