Here's some thoughts on the problems (and test cases):

   Problem 1:  Everyone got this sooner or later.  The only reason for
	       any failed submissions was not reading more than one line
	       of input.

   Problem 2:  The only problem I didn't write (this one came from Dr. Saunders)
	       My solutions is just flat out ugly (and, quite frankly,
	       a little embarrasing).  I'm not really sure what went
	       wrong as not many people tried it.

   Problem 3:  The Muppet Show just rules.  Anyway, the cases most people
               failed were when phenomena appeared, but not as a word by
	       itself.  It should not have triggered a response by the
	       Snowths if, say, phenemena appeared at the end of some
	       make beleive word.  It had to have been by itself as a word.

   Problem 4:  Boy did this one ever cause some people headaches.  One thing
	       that caused people some problems was using inappropriate
	       data types and/or functions to read them.  The input 
	       said the numbers would be smaller than 2^32.  Sure enough,
	       I'm sadistic enough to give such data as test cases.
               Thus, you needed to be able to actually read 2^32 - 1 as
	       a valid input.  At the very least, you need unsigned long
	       (or ints.  it's a 32 bit machine).   Some people tried using
	       atoi () to read the numbers (after parsing the input).  I'm
	       not certain if atoi will handle such large numbers correctly.
	       I think atol and strtoul (string to unsigned long) handle it.
	       (I used sscanf in my solution.)
   
	       One way of handling it is by actually multiplying out
	       everything and then subtracting off p until you get
	       something between 0 and p -1.  However, if you do this,
	       you're going to have to use large number multiplication
	       (ie, multiplying by strings).  It's not enough to just
	       multipy the numbers together as if they were ints.
 
	       That's not the preferred way, however.  The thing to realize
	       is that if you do  a b mod p  where a and b are integers,
	       that's equivalent to  (a mod p) * (b mod p) mod p.
	       In other words, you first reduce a and b to be members of the
	       group and then do the multiplication.  Since p is less than
	       half word size, (a mod p)  * (b mod p) will fit within
	       a 32 bit integer.  You have to do an extra mod just to
	       make sure you don't run up too large a value too soon.

	       Some people tried to do a long long int (64 bits).  That's
	       not gonna work either.  Like I said earlier, I can be
	       rather sadistic and nasty when it comes to making up test
	       data.  The pathological case was multiplying (2^32 - 1) 50
	       times.  That works out to something like 2^1600 (give or take
	       a bunch of intermediate terms).  So a long long ain't gonna
	       cut it.

    Problem 5:  One team tried it, but got a presentation error.  It's not
	       too bad if you can handle the arbitrarily long input.
	       The test case, btw, was something like 2.4 MB long.  The
	       easiest way to handle it with the use of things like
	       STL vector.

    Problem 6: One team tried it.  One team got it.