I'm having trouble with the following problems, it's a pair that goes like this:

6.3.1 [10] <6.2> Consider the following binary search algorithm (a classic divide and conquer algorithm) that searches for a value X in a sorted N-element array A and returns the index of matched entry:

BinarySearch(A[0..N1], X) {

low = 0

high = N 1

while (low <= high) {

mid = (low + high) / 2

if (A[mid] >X)

high = mid 1

else if (A[mid]

low = mid + 1

else return mid // found

} return 1 // not found

}

Assume that you have Y cores on a multi-core processor to run BinarySearch. Assuming that Y is much smaller than N, express the speedup factor you might expect to obtain for values of Y and N. Plot these on a graph.

6.3.2 [5] <6.2> Next, assume that Y is equal to N. How would this affect your conclusions in your previous answer? If you were tasked with obtaining the best speedup factor possible (i.e., strong scaling), explain how you might change this code to obtain it.