1. Write a subroutine that is given an integer number as input, will print out
a solid square in asterisks the size of that number. E.g., input is 5, output is
*****
*****
*****
*****
*****

2. Write a subroutine that is given an integer number as input, will print out
a hollow square in asterisks the size of that number. E.g., input is 5,
output is
*****
*   *
*   *
*   *
*****

3. Write a function that is given an integer, and will compute and return
its factorial. Factorial (denoted by an exclamation point) is an accumulation
by multiplying, e.g., 5! = 1*2*3*4*5  By definition, 0! = 1! = 1 .

4. Write a function that is given a character (string) called ch, and another
string called s and will return TRUE if the string s contains the given 
character ch, returns FALSE otherwise. (Hint, use the string manipulation
function Mid. This problem is less important than the others.)

5. Write a function that is given an array of characters and will return TRUE
or FALSE depending on if the characters form a palindrome (a string that reads
the same forwards and backwards). For example,
   G O H A N G A S A L A M I I M A L A S A G N A H O G
or
   M A D A M
or
   A B B A
would return a value of TRUE whereas
   H E L L O
would return a value of FALSE.

6. Write a subroutine that will allow for adding integer numbers larger than
can be typically handled by the machine. This is done by putting individual
digits into arrays. Assume a subroutine is given three dynamically allocated
arrays. The first two arrays have integers stored with one digit per element.
Resize the third array parameter so it can hold the sum of the first two
numbers. 

For example, say the arrays are called A, B, and sum.  The A array contains the
number two million, three hundred forty-two thousand and eight hundred
ninety-six, 2,342,896.  B holds 9,732.  Arrays are shown backwards for ease
of reading.

     +---+---+---+---+---+---+---+
  A: | 2 | 3 | 4 | 2 | 8 | 9 | 6 |
     +---+---+---+---+---+---+---+
       6   5   4   3   2   1   0
                 +---+---+---+---+
  B:             | 9 | 7 | 3 | 2 |
                 +---+---+---+---+

The subroutine should set the sum array to
     +---+---+---+---+---+---+---+
sum: | 2 | 3 | 5 | 2 | 6 | 2 | 8 |
     +---+---+---+---+---+---+---+
       6   5   4   3   2   1   0

7. Write a subroutine that is given two arrays. The first is filled with numeric
grades. The second is to be filled with letter grades based on a curve. The top
score gets an A. Scores within 5 points of the top score also get an A. Scores
within 15 points get a B. Scores within 25 points get a C. Scores within 35
points get a D. All others get an F. For example, if numericGrades is filled
as such

               +----+----+----+----+----+----+----+----+----+
numericGrades: | 82 | 73 | 56 | 94 | 66 | 25 | 80 | 75 | 90 |
               +----+----+----+----+----+----+----+----+----+

then letterGrades will be filled with

               +----+----+----+----+----+----+----+----+----+
 letterGrades: | B  | C  | F  | A  | D  | F  | B  | C  | A  |
               +----+----+----+----+----+----+----+----+----+