The exam will be in a format similar to the quizzes with some short answer, some writing of code, and some reading of code. The following exam should help prepare you for the longer questions.

Problem 0: Review old quizzes, homework assignments, and the self-check for chapter 2, 3, 4, 5, 6, and 14.

Problem 1: To draw an n-sided polygon of radius r centered at (x, y), we need to know the coordinates of each corner. If corners are numbered clockwise starting with corner 0 in the 3 o'clock position, then the coordinates of corner i are (x + r * cos(i * 360 / n), y + r * sin(i * 360 / n)) where angles are measured in degrees. Write a C++ statment that, given x, y, r, n, and i, draws the ith side of the polygon (that is, the line from corner i to corner i + 1). Keep in mind that C++'s trig functions expect angles to measured in radians. You may assume that there exists a header file draw.h which contains the following function:
drawLine(int x1, int y1, int x2, int y2) that draws a line between the coordinate pair (x1, y1) and (x2, y2).

Problem 2: Recall that the Card class has two instance variables rank and suit, both ints from Quiz 2.

• Add a new method in the Card class called makesPair that returns true if and only if the card the method is invoked on and the card passed as an argument have the same rank and color (and a different suit). Only write what would appear in the .cpp file. See below for an example of how makesPair would be used.

  Card a(2, Card::HEARTS);
  Card b(2, Card::CLUBS);
  Card c(2, Card::DIAMONDS);
  
  cout << a.makesPair(b) << endl; // should output false (different color)
  cout << a.makesPair(c) << endl; // should output true
  cout << a.makesPair(a) << endl; // should output false (same suit)
  

• Come up with a test that should be included in the test driver shown above.
• Write a new method in the Card class called isFlush() that determines if all the cards in the array passed as a parameter have the same suit. isFlush should return true if all the cards are of the same suit and false otherwise. See below for an example of how isFlush would be used.

  Card hand[] = {Card(3, Card::CLUBS), Card(4, Card::CLUBS), 
                 Card(Card::JACK, Card::HEARTS), Card(Card::QUEEN, Card::CLUBS),
                 Card(9, Card::CLUBS)}
  
  cout << Card::isFlush(hand, 5) << endl; // should output false
  
  hand[2] = Card(Card::JACK, Card::CLUBS);
  cout << Card::isFlush(hand, 5) << endl; // should output true
  

Problem 3: Format the following code properly. Figure out which case is unreachable. Are there any values of x and y for which two messages would be printed?

if (x > 10 && y < 5)
if (x > 5 && y < 0)
cout << "A" << endl;
if (x > 0 && y > 0)
if (x == 0)
cout << "B" << endl;
else
cout << "C" << endl;

Problem 4: The following method attempts to compute the sum 1! + 2! + ... + n!. It does not work correctly.

int factorialSum(int n)
{
    int sum = 0;
    int factorial = 0;
    
    for (int i = 1; i <= n; i++)
    {
	// compute i!

	for (int j = 1; j <= i; j++)
	    factorial *= j;

        // factorial should now hold i!; add it to the sum

	sum += factorial;
    }

    return sum;
}

• factorialSum(4) should return 33 (1! + 2! + 3! + 4! = 1 + 2 + 6 + 24). What does factorialSum(4) return using this implementation?
• Make minimal changes to the above code to make the method work.

Problem 5: For each of the following sequences of statements, write loops that are equivalent.

• Assume there is a function drawOval in the header file draw.h. This function has the prototype:
  void drawOval(int x, int y, int width, int height);
  The function drawOval works in the following manner. It creates a box and draws the oval inside the box. The pair (x,y) in the parameters gives the location of the upper left corner of the box. The parameter width indicates the width of the box, and the parameter height indicates the height of the box.
  Your answer may include only one call to the function drawOval.

  This draws 5 concentric circles. drawOval(0, 0, 100, 100); drawOval(10, 10, 80, 80); drawOval(20, 20, 60, 60); drawOval(30, 30, 40, 40); drawOval(40, 40, 20, 20);

• For this portion, your code may have only one call to drawLine

  This draws 3 triangles (polygons!) of radius 20 centered at (20, 20), (60, 20), and (100, 20). const double PI = 3.14159; int sides = 3; double sideAngle = 2 * PI / sides; double startAngle = PI / 2; drawLine(20 + (int)(20 * cos(startAngle)), 20 + (int)(20 * sin(startAngle)), 20 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle))); drawLine(20 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle)), 20 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle))); drawLine(20 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle)), 20 + (int)(20 * cos(startAngle + 3 * sideAngle)), 20 + (int)(20 * sin(startAngle + 3 * sideAngle))); drawLine(60 + (int)(20 * cos(startAngle)), 20 + (int)(20 * sin(startAngle)), 60 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle))); drawLine(60 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle)), 60 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle))); drawLine(60 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle)), 60 + (int)(20 * cos(startAngle + 3 * sideAngle)), 20 + (int)(20 * sin(startAngle + 3 * sideAngle))); drawLine(100 + (int)(20 * cos(startAngle)), 20 + (int)(20 * sin(startAngle)), 100 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle)))); drawLine(100 + (int)(20 * cos(startAngle + sideAngle)), 20 + (int)(20 * sin(startAngle + sideAngle)), 100 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle))); drawLine(100 + (int)(20 * cos(startAngle + 2 * sideAngle)), 20 + (int)(20 * sin(startAngle + 2 * sideAngle)), 100 + (int)(20 * cos(startAngle + 3 * sideAngle)), 20 + (int)(20 * sin(startAngle + 3 * sideAngle)));

  You are on your own for this picture. You may call drawLine only once.

Problem 6: Write methods to do each of the following.

• Return the product of the first n odd cubes. For example, if n is 3 your method should return 375 since 1³ * 3³ * 5³ = 375.
• Return the index of the first character in a string s that is alphabetically after its successor in s. For example, if s is ACDGKPLZ then the method should return 5 since P is alphabetically after L. You may assume that the characters in s are either all uppercase letters or all lowercase letters. Return the index after the last character if none fit this rule.
• Return the length of the shortest string in an array of strings called sarr, or -1 if the array is empty. The number of strings in the array is given in the parameter size.
• Return the shortest string in an array of strings called sarr, or the empty string if there are no strings in the array. The number of strings in the array is given in the parameter size.
• Return the location of the first string in an array of strings called sarr that contains a space, or -1 if there is no such string. The number of strings in the array is given in the parameter size.

Problem 7: Write a code fragment that creates a 10 row, 5 column array of ints, initializes all elements of that array to random integers from 1 to 9, and then displays the sum of all the entries and the index of the row that has the highest total.