Assignment 3: Algorithm Analysis

To find the smallest value in a collection ...
Set smallestSoFar to one value in the collection
While unchecked values remain in the collection
  Pick one
  If that value is smaller than guess then
    Set smallestSoFar to that value
Return smallestSoFar

To find the smallest value in a collection ...
If the collection is empty then
  Report an error
Otherwise, if the collection has only one value then
  Return that value
Otherwise
  Split the collection into two parts
  Find the smallest value in each part
  Take the minimum of those two values

To find the smallest difference between any two 
  different numbers in a collection ...
List all pairs of different numbers in the collection
Set estimate to 
  the difference between the values in the first pair
For each remaining pair
  Compute the difference between the two values
  If that differences is less than estimate then
    Set estimate to that difference
Return estimate

To find the smallest difference between any two 
  different numbers in a collection ...
Set estimate to ``infinity''
For each value, v, in the collection
  For each value, u, not equal to v
    If |u-v| < estimate then
      Set estimate to |u-v|
Return estimate

/**
 * Compute the square root of val to accuracy 1/n.
 * Pre: (1) val >= 0
 *      (2) n > 0
 *      (3) The square root of val can be represented.
 * Post: (1) Returns a value v such that |v-sqrt(val)| < 1/n.
 */
public static double sqrt(double val, long n) {
  // Compute 1/nth of the range of possible values
  double accuracy = 1.0/((double) n);
  // Start with an initial guess
  double guess = 0;
  // Determine the difference between the square of the guess
  // and the actual square root.
  double diffsquared = val;

  // Step through all the possible values between 0 and val.
  for (double nextguess = 0.0;
       nextguess <= val;
       nextguess = nextguess + accuracy) {
    // Compute the difference between the square of the guess
    // and the actual value.
    double nextdiff = Math.abs(nextguess*nextguess-val);
    // If it's better, use it.
    if (nextdiff < diffsquared) {
      guess = nextguess;
      diffsquared = nextdiff;
    }
  } // for
  return guess;
} // sqrt(double,double)

/**
 * Compute the minimum number of stamps that exactly
 * totals val cents.  
 * Pre: (1) val >= 0
 *      (2) All stamps values are positive.
 *      (3) It is possible to combine stamps for any value.
 * Post: Returns N such that it is possible to buy N stamps
 *   for exactly val and it is not possible to buy M < N 
 *   stamps for exactly val.
 */
public static int minimumStamps(
  int val, 
  int[] stampValues)
{
  // Base case: You need no stamps for 0 cents.
  if (val == 0) {
    return 0;
  }
  // Recursive case: Minimize alternatives
  else {
    int i = 0; // An index into stampValues
    int guess; // Our best guess so far as to the minimum.
    int nextGuess;  // Another guess to try
    int stampToBuy; // The stamp to buy in this round.

    // Find the first stamp that's still worth buying.
    while (stampValues[i] > val)
      i++;

    // We might buy that stamp.
    stampToBuy = stampValues[i];
    int guess = 1 + minimumStamps(val-stampValues[i], stampValues);

    // But we might also buy other stamps.
    for (i = i+1; i < stampValues.length; i++) {
      if (stampValues[i] <= val) {
        nextGuess = 
          1 + minimumStamps(val-stampValues[i], stampValues);
        if (nextGuess < guess) {
          stampToBuy = stampValues[i];
          guess = nextGuess;
        }
      } // if the stamp is worth buying.
    } // for
    
    // That's it, we're done
    return guess;
  } // recursive case
} // minimumStamps(int, int[])