java

Let A be an array of integers (positive or negative). Assume that the array is of size n. The subarray A[i..j] is the part of the array that starts at index i and ends at index j, where 0 i j n-1. Let s_ij equal the sum of the integers in A[i..j].

We wish to solve the following problem:

Find the maximum value for s_ij over all subarrays with maximum leght of 3 in array A, where 0 i j n-1.

The three algorithms given below solve this problem. NOTE: If all of the values in the array are negative, then the maximum value for s_ij is 0 by default.

Example: If the array contains the values { -1, 12, -3, 14, -4, 3 }, then the maximum sum over all subarrays is 23 (for the subarray {12, -3, 14}). If the array contains the values { 2, -3, 5, -1, 7}, then the maximum sum over all subarrays is 11 (for the subarray {5, -1, 7}).

ALGORITHM 1

Start with a maximum sum of 0. Compute the sum of each 1-element subarray, then compute the sum of each 2-element subarray, then compute the sum of each 3-element subarray, etc. For each sum you compute, if it is larger than the maximum sum youve seen, then it becomes the maximum sum.

Write a class MethodTester that contains a main method and three static helper methods, one to implement each algorithm above. Your main method should test your methods with small arrays (like the ones in the examples above) so you know they work correctly before moving on.

Once you know the algorithms work correctly, write another class named RuntimeAnalyzer that contains the same helper methods. Modify each helper method so that it returns the number of assignment statements that it performs rather than the maximum sum over all subarrays. Do this by adding a counter to each algorithm that starts at 0 and increments each time you do an assignment statement. You should decide what qualifies as an assignment statement. Be consistent across algorithms so you can compare the algorithms against each other.

Or instead you could measure the time that your computer spends processing the algorithm using:

long startTime = System.currentTimeMillis( ); // record the starting time /* (run the algorithm) */ long endTime = System.currentTimeMillis( ); // record the ending time long elapsed = endTime  startTime; 

If your computer is too fast use:

long startTime = System.nanoTime(); // record the starting time /* (run the algorithm) */ long endTime = System.nanoTime(); // record the ending time long elapsed = endTime  startTime; 

Write your main method for this class so it will run your algorithms for randomly generated arrays of size 5, 10, 15, , up to 50. Each array should have random values between -10 and 99, inclusive, and you can have duplicates.

To generate a random number between x and y, use the following Java expression:

(int)(Math.random()*(y-x+1) + x) 

For each array size, generate 20 arrays (one at a time) and run the algorithms with each array, averaging the returned number of assignment statements executed for each algorithm separately.