Comparator contracts

Questions 1 to 5 of 8

1. 1. A student sorts people by age, oldest first, with this comparator. What is the problem? ``cpp std::sort(people.begin(), people.end(), [](const Person& a, const Person& b) { return a.age >= b.age; }); ``

   It says a person comes before themselves, which breaks the irreflexive rule and can crash the sort or give a wrong orderIt sorts from youngest to oldest, which is the reverse of what was askedIt does not compile, because age is an intIt is slow, because it compares ages one at a time
2. 2. A comparator returns the result of a subtraction, as in this code. What is wrong with it? ``cpp std::sort(v.begin(), v.end(), [](int a, int b) { return a - b; }); ``

   It is a compile error, because a - b is not a boolIt sorts in descending order, because subtraction reverses the signIt is a valid comparator, because a number can be used as a boolAny non-zero result counts as true, so a and b can each come before the other, which breaks asymmetry
3. 3. This comparator is meant to sort by length, then by text. What does g++ report? ``cpp return std::tie(a.size(), a) < std::tie(b.size(), b); ``

   It breaks the irreflexive rule, so the sort may crash at run timeIt compiles and sorts only by the text, ignoring the lengthIt does not compile, because a.size() returns a value with no name, and std::tie needs references to real variablesIt compiles and sorts the longest words first
4. 4. The comparator b - a > 0.1 is used on the values 0.0, 0.08 and 0.16 to treat close values as tied. Is it a valid comparator for these three values?

   True, because every pair within 0.1 of each other is tied, so the ties are consistentTrue, because a comparator that uses > is always valid, whatever it comparesFalse, because 0.0 is tied with 0.08 and 0.08 is tied with 0.16, but 0.0 is not tied with 0.16, so ties do not pass along a chainFalse, because subtracting two doubles always overflows
5. 5. The comparator [](int a, int b) { return a > b; } is used to sort in descending order. Is it a valid comparator?

   False, because descending order needs >=, so that ties can be keptFalse, because a valid comparator must keep equal items in their original orderFalse, because > makes each item come before itself when the values are equalTrue, because > is the strict form: nothing comes before itself, and the order is consistent