Algorithms. 1. At a high level of abstraction, the algorithm for doing laundry is:

Size: px

Start display at page:

Download "Algorithms. 1. At a high level of abstraction, the algorithm for doing laundry is:"

Caitlin Lynch
6 years ago
Views:

1 Algorithms 1. At a high level of abstraction, the algorithm for doing laundry is: Wash clothes Dry clothes Put clothes away Using the principle of stepwise refinement, write more detailed pseudocode algorithms for each of these three steps at a lower level of abstraction. There are many possible solutions, but a correct solution would resemble the following: Algorithm WashClothes open washer add clothes add soap close washer choose wash cycle wait until done Algorithm DryClothes open washer open dryer move clothes to dryer close dryer choose dry cycle wait until done Algorithm PutClothesAway open dryer remove clothes fold clothes sort clothes by type put clothes in drawers depending on type

2 2. When designing algorithms in a top-down fashion using stepwise refinement, it is common to refine a task by replacing with a call to another algorithm rather than inserting the subtasks into the existing algorithm. This promotes code reuse. Consider the algorithm below for computing marks for exam: Algorithm computemarks (Answers, numstudents, numquestions) Pre: answers is a 2D integer array where Answers[i][j] is 1 if student i answered question j correctly and 0 otherwise. numstudents is the number of students. Post: grades is an integer array where Grades[i] is the number of correct answers given by student i. loop( i < numstudents ) numcorrect sum of Answers[i][0] through Answers[i][numQuestions] grades[i] numcorrect (a) Write the algorithm header for the boxed task in the algorithm and rewrite the computemarks algorithm to make use of your new summation algorithm (note: you don t have to write the pseudocode for the summation, just the algorithm header). (b) Write a pseudocode algorithm for computing the sum of all elements in a two dimensional matrix (array) which reuses the summation algorithm from part a) (note that you can do this with knowledge of only the algorithm header and do not need to have the actual pseudocode for the summation algorithm a benefit of abstraction!). (a) Algorithm arraysum( A, sizea) Computes the sum of the elements in an array. Pre: A is an integer array of sizea elements. Return: the sum of the elements in A Algorithm computemarks (Answers, numstudents, numquestions) Pre: answers is a 2D integer array where Answers[i][j] is 1 if student i answered question j correctly and 0 otherwise. numstudents is the number of students. Post: grades is an integer array where Grades[i] is the number of correct answers given by student i. loop( i < numstudents ) grades[i] arraysum(answers[i], numquestions)

3 (b) Algorithm sumofmatrixelements( M, numrows, numcols ) Computes the sum of all the elements of the matrix (2D array) M. Pre: M is a 2D array of numbers. Returns: The sum of all elemetns in M matrixsum 0 loop( i < numrows) matrixsum = matrixsum + arraysum( M[i], numcols ); return matrixsum

4 Big-Oh Notation 1. Consider the following loop. for(i=1; i < n; i *= 2) doit(...) (a) What is the worst case time complexity (Big-Oh) of this loop if doit(...) is an O(1) algorithm? (b)... an O(n 2 ) algorithm? Justify your answers and show all your work. (a) For each loop iteration, a constant-time algorithm is executed, plus 2 ops for the comparison and the increment, resulting in O(1)+2 ops per iteration. The loop executes log n times so the total number of operations is log(n) (O(1) + 2) log(n) O(1) O(log n). (b) The loop still executes log n times, but now, on each iteration, we have O(n 2 ) + 2 operations for a total of log(n) (O(n 2 ) + 2)) log(n) O(n 2 ) O(n 2 log n). 2. Determine the Big-Oh notation for the following: 5*n 5/2 + n 2/5 3*n 4 + n*log(n)

5 3. Find the worst case time complexity (Big-Oh) of the following algorithm. Justify your answer and show all your work. Algorithm squareroot ( k ) Approximates the square root of k using the "Babylonian Method". Pre: k is an integer Returns: approximation of square root of k guess 1.0 loop ( i < 100 ) guess (guess + k/guess) / 2.0 The loop body contains 4 primitive operations (3 arithmetic + 1 assignment). The loop executes 100 times and the comparison contains one primitive operation. Thus, the loop results in primitive operations. There are 2 primitive operations in the initialization of guess and i, so the total number of primitive operations is 502 (602 if you count the increment in the loop). This is independent of the input size, so the time complexity is O(502) O(1). In other words, the algorithm always takes the same amount of time regardless of the input (although, as the input value becomes larger, the accuracy of the approximated square root decreases).

6 4. Find the worst case time complexity (big-oh) of the following algorithm. Justify your answer and show all of your work. Algorithm selectkth (values, n) Find the median element of an (unsorted) array of integers. Pre: values is an array of integers n is the number of elements in values Returns: the median of the numbers in values for( ; i < n/2; i++ ) mini i; for(j=i+1; j < n; j++) if( values[j] < a[mini] ) mini j end if tmp a[i] a[i] a[mini] a[mini] tmp return a[n/2] First we will analyze the inner loop. The body of the inner loop contains 4 primitive operations in the worst case (2 array index + 1 comparison + 1 assignment). The inner loop executes n i 1 (because j takes on values i+1 to n 1) with 1 operation used for the comparison. So the total number of iterations of the inner loop is 5(n i 1). Now we can consider the outer loop. The outer loop executes n/2 times, for i = 0 through n/2 1. There are 3 operations before the inner loop (2 assignments, one addition) then the inner loop, then 7 operations after the inner loop (4 array index, 3 assignment).

7 We could simply this more, but it is clearly O(n2).

Comparison of x with an entry in the array

Comparison of x with an entry in the array 1. Basic operations in algorithm An algorithm to solve a particular task employs some set of basic operations. When we estimate the amount of work done by an algorithm we usually do not consider all the