Question

Refer to the following program sample to answer the parts (a-i) below. Keep in mind that low and high are both indices of array A. /1 Assume that A is a sorted array containing N integers // Assume that x is a variable of type int int low= 0; // Line 1 int high- N; // Line 2 while (low- high) I/ Line 3 m- (lowthigh)/2; // Line 4 (This is integer division) if (A [m]0, where (N-1) (N-1) (N-1)- K what array A would you use? In which variable is the approximate cube root computed? An approximate cube root of r 2 1 is the largest integer y such that (y-1)3 0, where (N-1)*(N-1)*(N-1)- K. Give brief reasons. h. (3 marks) Assuming that the array is already initialised, what is the worst-case execution of finding cube roots using this method? (Use Big Oh.) Page 5 i. (4 marks) You can change the program above at eractly one line to avoid using the array A to compute approximate cube roots for any integer K>0, where (N-1) (N-1)*(N-1)- K. Which line is it and how does it change? Your change should only use basic arithmetic operations: e.g. multiplication/division, addition/subtraction, comparison.

Answer 1

(a) Here A = [1,1,1,1] and x = 1. At the termination of loop, low = 0. This is because

At the start of the loop, low = 0 while high = 4

(i) Inside the first iteration, m= 2, low is kept at 0 while high is set to 2

(ii) Inside the second iteration, m is set to 1, low is kept at 0 and high is set to 1

(iii) Inside the third iteration, m is set to 0, low is kept at 0 while high is set to 0

So, the loop terminates after 3 iterations

(b) Here A = [1,1,1,1] and x = 2. At the termination of loop, low = 4. This is because

At the start of the loop, low = 0 while high = 4

(i) Inside the first iteration, m = 2 and low is set to 3 while high is kept at 4

(ii) Inside the second iteration, m = 3 and low is set to 4 while high is kept at 4

Hence, the loop terminates after 2 iterations

(c) Here A = [1,1,1,1] and x = 0. At the termination of loop, low = 0. This is because

At the start of the loop, low = 0 while high = 4

(i) Inside the first iteration, m= 2, low is kept at 0 while high is set to 2

(ii) Inside the second iteration, m is set to 1, low is kept at 0 and high is set to 1

(iii) Inside the third iteration, m is set to 0, low is kept at 0 while high is set to 0

So, the loop terminates after 3 iterations

(d) Here A = [0,1,4,9,16,25,36,49] and x = 9. At the termination of loop, low = 3. This is because

At the start of the loop, low = 0 while high = 8

(i) Inside the first iteration, m = 4. Since A[4] > 9 , high is set to 4 while low is kept at 0

(ii) Inside the second iteration, m = 2. Since A[2] < 9 , low is set to 3 while high is kept at 4

(iii) Inside the third iteration, m = 3. Since A[3] = 9, high is set to 3 while low is kept at 3.

Thus, the loop terminates after 3 iterations

(e) Here A = [0,1,4,9,16,25,36,49] and x = 10. At the termination of loop, low =4 . This is because

At the start of the loop, low = 0 while high = 8

(i) Inside the first iteration, m = 4. Since A[4] > 10 , high is set to 4 while low is kept at 0

(ii) Inside the second iteration, m = 2. Since A[2] < 10 , low is set to 3 while high is kept at 4

(iii) Inside the third iteration, m = 3. Since A[3] < 10, low is set to 4 while high is kept at 4 .

Thus, the loop terminates after 3 iterations

(f) We can choose an array A = [ 0, 1, 2³, 3³, 4³, 5³, 6³,......, (N-1)³]. The variable low contains the index of the approximate cube root. A[low] would be the approximate cube root

(g) The size of the array required is N since we would need to keep every integer from 0 to N-1 as each can be a possible candidate for an approximate root.

(h) At each step, either low is set to (low+high)/2 + 1 or high is set to (low+high)/2. That is in each step, the search space reduces by half. Since, there are originally n elements in the array and each iteration reduces the search space by half, time complexity is O(n) .

(i) We change Line 5. Instead of if (A[m] < x) , we can write if( m³ < x) . Rewriting the whole code below :-

int low = 0; // Line 1

int high = N; // Line 2

while(low != high) { // Line 3

m = (low + high)/2 ; // Line 4 (This is integer division)

if ( m³ < x ) // Line 5 ( this is where we change our code )

then low = m +1; // Line 6

else high = m; // Line 7

}