1) Prompt user to enter positive N (max value 200).  Error check N.
   Write a loop that assigns the first N elements of the array A to
   100.0*(element index)  
   -i.e., A(1) = 100, A(2) = 200, etc.
   -> Add another array (B), and copy the N elts of A into it with a loop
   -> Rewrite the copy loop to use subsection assignment
   -> Use subsection to assign odd elements of B to 0, even elements to
      the odd elements of A (N will need to be an even number for this to work)

2) Prompt user to enter N, the number in the sequence to compute, and
   the initial seed values S0 and S1.  Then compute and print the
   first N+1 entries of the sequence:
      S(i) = 100*S(i-2) + S(i-1)
   using an array.  You can restrict N <= 200, and you should error check
   the users input to make sure this is true (also check for invalid numbers
   such as negative numbers).
   -> Use an allocatable array and remove the maximum restriction on N!

3) Write do-loop implementations of all array intrinsics on slide 6 except
   size (which you can't really do), and perform error checks of your answer
   versus the intrinsics, as on slide 6.  For each of these problems, declare
   the vector length as a parameter.
   -> I suggest starting with SUM
   -> rewrite to prompt user for N, and use allocatable arrays
   -> For your MAXVAL and MINVAL loop implementations, change them so that
      you print out not only the MAX/MIN, but also the array entry where
      the MAX/MIN was found
   -> For one routine (say MAXVAL), try changing your loop type
      (eg., counter loop->logical loop)

4) Write a program that randomly generates an array of length N (N is an
   integer parameter set by you), and writes it to a file.
   -> Rewrite to use allocatable array, and have it write N as first
      entry in output file.
   -> Vary the type of array you are generating (integer, double precision, etc)

5) Write a program that reads in the file created in #3, and sorts the array
   from greatest-to-least
   -> Rewrite to handle new type of file from #3 (differing data types and
      allocatable arrays based on N, etc).
   -> Rewrite for least-to-greatest

6) Write a program containing two double precisions arrays of dimension N,
   where N is an integer parameter (initially set to a small number like 5).
   Initalize the first array using a call to RANDOM_NUMBER.  Now, write
   a loop that fills in the second array, with only those elements of
   the first array that are <= 0.5.  Set all other entries of the second
   array to zero.  Therefore, if our first array is
      [0.9, 0.7, 0.2, 0.6, 0.1]
   then our second array would wind up as:
      [0.2, 0.1, 0.0, 0.0, 0.0]
   Debug your routine by printing both arrays to the screen and verifying.