Given that several students clearly went on a wrong path
   with project 1, it is a very good idea to *plan* project 2
   before starting to write code. I recommend that you start with an outline
   of C++ classes in your project. In general, it is a good idea to represent
   a separate concept as a class, but you also want to maximally reuse your
   code. You also want to be able to compile and run pieces of code as early
   as possible, otherwise, you will type a thousand lines of code only to see
   them seg-fault somewhere in the middle (=> very hard to debug). So, there
   should be a consideration for testing. For example, using an 2-dim array
   class (for proj 1) that overloads operator() allows you to add array bounds
   checking right in the op(), but if you dereference pointers twice (as in C), 
   array bounds checking is not as straightforward.

   For project 2, you probably want to dedicate a class that represents 
   the boundary of a convex hull (e.g., by storing points in a clock-wise
   order). That class can be even publicly inherited from vector<Point>
   or stack<Point>, etc. If you don't want the methods of vector/stack/etc
   to propagate to the class, can use it as private or protected data
   (in which case overloading op[] may be a good idea). This class could
   have various I/O methods and ops (e.g., draw itself, read, write from
   file if needed) and also a constructor from  const vector<Point>& pointset
   that would "hide" your convex hull computation (i.e., compute the boundary
   of the convex hull of a given pointset).

   Hiding various algorithms into ctors often dramatically simplifies
   client code and makes them more reusable (since the result is available
   as a class that "can tell you all about itself").

   So, for part 2, you would start with locations of sharks and yachts.
   Then independently construct their convex hulls (in 1-2 lines of client code),
   and then do the rest in a global function that would return a bool
   (no need for a class since the result is just one byte).

   This way, your whole project 2 will become reusable -- it's just
   one function that takes two vectors on the input (+ potentially some
   parameters, such as turning on diagnostics at different levels of verbosity),
   and returns a bool at the output. After this   main()   becomes very simple --
   it would read the data, start a timer, call your function, stop the timer,
   report the result and report time.
 
   Hope this helps 
   (but note that the above does not discuss the algorithm, 
    so it will make little sense to turn it in as algorithm.txt).