Problem 1: Fuzzy MD5 Checking

   -- This was mostly straightforward.  You do, though, have to keep track
      of all the checksums in a given test case.  It's not one line of
      output per checksum.  Some of the other common errors may have
      been off by one errors.

Problem 2: Palindromes

   -- Some of the failed submissions for this produced too much output.
      You can't write a loop like this:

      while (!cin.eof ()) {
          cin >> inp;

	  //do something with inp
      }

      eof is *NOT* tripped until you try to read from a stream that
      is at the end of file.  In other words, cin.eof () will not
      be true until *after* you do the cin >> inp and input has reached
      the end of file.  If you are at the end of file, then cin.eof ()
      will be true, the cin >> inp will fail, but nothing will be written
      to inp.  So your code will process the last input again and you
      get an extra line of output.
      
      You have to add in the condition again after doing that read, or 
      write the loop like:

      while (cin >> inp) {
          // do something with inp
      }

Problem 3: The Forest from the Trees

   -- This is a graph reachability problem.  Starting from one tree, you 
      can do a breadth first search on its neighbors to discover all the
      trees that are directly connected to the start.  Keep expanding
      those trees until you run out.  That's one forest.  Repeat as
      many times as you need to until all the trees have been placed
      into a forest.

   -- The test input used 1,000 trees in 2 separate cases where each
      tree was connected to (almost) all other trees.  One test case
      had one tree by itself.  This gave a time limit problem for
      some submissions.

Problem 4: Sorting Song Titles

   -- The sorting is straightforward *if* you can parse the songs
      to skip whitespace, punctuation and take out the articles.
      My solution splits the song title up by the '/', lowercases
      the parts, parses by the spaces to find the articles and remove
      them, then puts the parts together for the sorting.  

   -- Some issues I saw were that people sorted by the artist first, rather
      than by the song name first, or not printing the entire song list
      at the end.

Problem 5: Jimmy's Card Game

   -- This game is silly.  You can win it, but only if the
      cards are dealt really nicely.

Problem 6: Turbulence Decompositions

   -- This problem was actually pretty simple, if you could parse
      all the verboseness in the problem description and see what is
      going on.  You read in all the data, compute the mean, and
      then subtract the mean from each value to get the fluctuations.

   -- The most common reason for failure was processing too much data and then
      getting NANs as a result, or not initializing variables correctly.