Solutions are now available.

Problem 0: Review old quizzes, homework assignments, and labs.

Problem 1: Review the following vocabulary and, where appropriate, the corresponding Java syntax.

• software engineering
• programming language
• compiler
• syntax
• semantics
• errors: syntax, semantic, run-time, logic
• algorithm
• pseudocode
• declaration
• data type
• identifier
• assignment
• initialization
• expression
• variable
• constant
• literal
• operator
• keyword (reserved word)
• package
• class
• reference
• primitive type
• instance
• object
• instantiation
• field
• constructor
• formal argument (parameter) list
• actual argument (parameter) list
• method
• invocation
• class (static) method
• instance (non-static) method
• return type
• mutator
• accessor
• factory method
• string
• string literal
• conditional
• loop
• Boolean
• array
• binary
• hexadecimal
• 2's complement
• excess notation
• software life cycle
• requirements
• design
• implementation
• UML
• white-box testing
• black-box testing
• waterfall model
• incremental model
• iterative model

Problem 2: 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)) wbere angles are measured in degrees. Write a Java statement 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 Java's trig functions expect angles to measured in radians and that the Graphics methods take ints as arguments.

Problem 3: Encode each of the following using the 8-bit two's complement system.

• 120
• -120
• 17
• -17

Problem 4: Encode each of the following using the floating point scheme described in Brookshear, Ch. 1.

• -4.5
• 0.6 (get as close as you can)

Problem 5: Write each of the following as

• hexadecimal digits,
• a positive integer,
• an integer encoded using two's complement, and
• a floating point number encoded using the scheme in Brookshear, Ch. 1.

• 01011001
• 10111010

Problem 6: Write a machine language program for the machine described in Brookshear, App. C that computes 12x + 8y. Assume that x has been stored in memory cell F0 and y has been stored in cell F1 before the program is executed. Store the result in cell F2.

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

• Write 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). See below for an example of how makesPair would be used.

  Card a = new Card(2, Card.HEARTS);
  Card b = new Card(2, Card.CLUBS);
  Card c = new Card(2, Card.DIAMONDS);
  
  System.out.println(a.makesPair(b)); // should output false (different color)
  System.out.println(a.makesPair(c)); // should output true
  System.out.println(a.makesPair(a)); // 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 = new Card(5);
  hand[0] = new Card(3, Card.CLUBS);
  hand[1] = new Card(4, Card.CLUBS);
  hand[2] = new Card(Card.JACK, Card.HEARTS);
  hand[3] = new Card(Card.QUEEN, Card.CLUBS);
  hand[4] = new Card(9, Card.CLUBS);
  
  System.out.println(Card.isFlush(hand)); // should output false
  
  hand[2] = new Card(Card.JACK, Card.CLUBS);
  System.out.println(Card.isFlush(hand)); // should output true
  

Problem 8: 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)
System.out.println("A");
if (x > 0 && y > 0)
if (x == 0)
System.out.println("B");
else
System.out.println("C");

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

    public static 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.
• Make more changes to avoid the nested loops.

Problem 10: For each of the following sequences of statements, write loops that are equivalent. Each answer should have only one line that calls the drawLine method.

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

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

You are on your own for this picture.

Problem 11: 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 length of the shortest String in an array of Strings called sarr, or infinity if the array is empty.
• Return the shortest String in an array of Strings called sarr, or null if the array is empty.
• Return the location of the first String in an array of Strings called sarr that contains a space, or -1 of there is no such String.

Problem 12: Write a class called Song with fields for the title and the artist. Include constructors, accessors, mutators, an equals method and a toString method.

Problem 13: Write a class called Quadratic to represent quadratic functions. The class should have three fields for the three coefficients of the function. Include a zero-argument constructor, a constructor that allows all three coefficients to be set, a method double getCoefficient(int which) to return a coefficient, and a method double evaluate(int x) to return the value of the function for a particular value of x.

Problem 14: Write a code fragment that creates a 10 element array of ints, initializes all elements of that array to random integers from 1 to 99, and then displays the sum of all the entries and the index of the element that has the highest value.

Problem 15: Write a method that takes two arrays of doubles as arguments and returns a new array that is the same size as the ones passed in and that contains elements initialized to the sum of the corresponding elements in the arguments. For example, if the two arrays passed in as arguments are [1 2 3 4 5] and [10 20 30 40 50] then the array returned should contain [11 22 33 44 55]. You may assume that the two arrays passed in have the same number of elements.

Problem 16: Write a method that takes an array of int as arguments and modifies that array so that every element is set equal to the largest value that was originally in the array. For example, if the array originally contains [1 6 3 8 3 2] then the method should change it to [8 8 8 8 8 8].