Return to Answer

###Problems I see:

Problems I see:

#include <algorithm>
#include <iterator>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <map>
#include <cctype>
class Car
{
 public:
 bool operator<(Car const& rhs) const {return name < rhs.name;}
 private:
  friend std::istream& operator>>(std::istream& stream, Car& self);
 friend std::ostream& operator<<(std::ostream& stream, Car const& self);
 std::string name;
};
std::istream& operator>>(std::istream& stream, Car& self)
{
 std::string line;
  std::getline(stream, line);
 std::stringstream linestream(line);
 linestream >> self.name; // This strips white space
 // Lowercase the name
 std::transform(self.name.begin(), self.name.end(), self.name.begin(), ::tolower);
 // Uppercase first letter because most are proper nouns
 self.name[0] = ::toupper(self.name[0]);
 return stream;
}
std::ostream& operator<<(std::ostream& stream, Car const& self)
{
 return stream << self.name << "\n";
}

//Print out map members
struct MapPrinter
{
 MapPrinter(std::map<Car,int>::value_type const& d): data(d) {}
 std::map<Car,int>::value_type const& data;
};
std::ostream& operator<<(std::ostream& stream, MapPrinter const& item)
{
 return stream << item.data.second << ": " << item.data.first;
}
int main(int argc, char* argv[])
{
 if (argc < 2)
 { exit(1);
 }
 std::ifstream cars(argv[1]);
 std::map<Car,int> count;
 Car nextCar;
 while(cars >> nextCar)
 {
 ++count[nextCar];
 }
 // PS deliberately left the sorting by inverse order as an exercise.
 std::copy(count.begin(),
  count.end(),
 std::ostream_iterator<MapPrinter>(std::cout));
}

#include <algorithm>
#include <iterator>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <map>
#include <cctype>
class Car
{
 public:
 bool operator<(Car const& rhs) const {return name < rhs.name;}
 friend std::istream& operator>>(std::istream& stream, Car& self)
 {
 std::string line;
 std::getline(stream, line);
 std::stringstream linestream(line);
 linestream >> self.name; // This strips white space
 // Lowercase the name
 std::transform(self.name.begin(), self.name.end(), self.name.begin(), ::tolower);
 // Uppercase first letter because most are proper nouns
 self.name[0] = ::toupper(self.name[0]);
 return stream;
}
 friend std::ostream& operator<<(std::ostream& stream, Car const& self)
 {
 return stream << self.name << "\n";
 }
 private:
  std::string name;
};
int main(int argc, char* argv[])
{
 if (argc < 2)
 { exit(1);
 }
 std::ifstream cars(argv[1]);
 std::map<Car,int> count;
 Car nextCar;
 while(cars >> nextCar)
 {
 ++count[nextCar];
 }
 // PS deliberately left the sorting by inverse order as an exercise.
 for(auto const& car: count) {
 std::cout << car.first << ": " << car.second << "\n";
  }
}

Next the objects you new are stored in RAW pointers. This is a dead give away that you are not an experienced C++ programmer. There should practically never be any pointers in your code. (All pointers should be managed by an object). Even though you manually do delete these two it is not done in an exception safe way (so they can still potentially leak).

std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower());
 // ^^^^^^^^^^^ or a custom 
 // functor to do the task

This one fact would have caused you to be rejected. I would have seen this and I would not have read any-further into your code straight onto the reject pile. This fundamental flaw in your style shows that you are not a C++ programmer.

Next the objects you new are stored in RAW pointers. This is a dead give away that you are not an experienced C++ programmer. There should practically never be any pointers in your code. (All pointers should be managed by an object). Even though you manually do delete these two it is not done in an exception safe way (so they can still potentially leak).

std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower());
 // ^^^^^^^^^^^ or a custom 
 // functor to do the task

Const correctness.

void reorg_by_count(map<string, int> &lines, multimap<int, string> &bycount)

The parameter lines is not mutated by the function nor should it be. I would expect it to be passed as a const reference as part of the documentation of the function that you are not going to mutate it. This also helps in future maintenance as it stops people from accidentally mutating the object in a way that later code would not expect.