Let An= {a;}, denote a list of n distinct positive integers. The median mA ÖI An Is a in An such that half the elements in An are less than m (and so, the other half are greater than or equal m). In fact, the median element is said to have a middle rank. (a) Develop an algorithm that uses Sorting to return mA given An. (6%) (b) Now assume that one is given another list B, = {b;}"1 of n distinct positive integers whose median mg is already known. Develop an algorithm that returns the sum of the two elements with value closest to mg, such that one of them is greater than mg and the other is lower than mg. Although sorting Bn would yield a quick solution, we will see later on that this is a exhorbitantly slow process and one can solve the problem without sorting B, in singnificantly faster time. Hence, in your solution, Do Not Sort B, and propose a solution that goes without Sorting. (6%) %3D (c) State a loop invariant for the algorithm you proposed in part (b) above.(6%) (d) Prove the loop invariant you proposed in part (c) above.(7%)

Let An= {a;}, denote a list of n distinct positive integers. The median mA ÖI An Is a in An such that half the elements in An are less than m (and so, the other half are greater than or equal m). In fact, the median element is said to have a middle rank. (a) Develop an algorithm that uses Sorting to return mA given An. (6%) (b) Now assume that one is given another list B, = {b;}"1 of n distinct positive integers whose median mg is already known. Develop an algorithm that returns the sum of the two elements with value closest to mg, such that one of them is greater than mg and the other is lower than mg. Although sorting Bn would yield a quick solution, we will see later on that this is a exhorbitantly slow process and one can solve the problem without sorting B, in singnificantly faster time. Hence, in your solution, Do Not Sort B, and propose a solution that goes without Sorting. (6%) %3D (c) State a loop invariant for the algorithm you proposed in part (b) above.(6%) (d) Prove the loop invariant you proposed in part (c) above.(7%)

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Pls answer correctly and show all work
Consider the following function that takes a list of elements (alist) sorted in increasing order and an element (elem) to search in the list. Suppose the length of alist is n. What is the worst case runtime of this algorithm? def search_inc_again(alist, elem): for i in alist: if i == elem: return True if i > elem: return False return False Question options: a. O(1) b. O(log n) c. O(n) d. O(n^2)
Consider the searching problem:Input: A sequence of n numbers A = [a1; a2; : : : ; an] and a value v.Output: An index i such that v = A[i] or the special value NILL if v does not appear in A.(i) Write pseudocode for linear search, which scans through the sequence, looking for v.(write the code)(ii) Using a loop invariant, prove that your algorithm is correct. proof by induction base case inductive step and proof of corretness
Referring to InsertionSort: (a) Prove using mathematical induction that for all 0 ≤ i ≤n-1 that after the for loop ends each i that the 0,....i elements of the list are sorted. (b) Use your answer to (a) to conclude mathematically that InsertionSort works.
3. Consider the following algorithm, called sorted greedy makespan algorithm. On input k and a list t1, ..., tm, it sorts the lengths of the tasks non-increasingly and applies the greedy makespan algorithm. We can combine 3 true statements in the above list to prove that this algorithm is a p-approximation for some p > 1. What is the smallest p that you get as a function of k?
Design of algorithms - divide-and-conquer: (a) Design a divide-and-conquer algorithm DC_PROD that receives as input an array A with n>0 integers and returns the product of the elements in A. You may assume n is a power of 2. In your algorithm identify the relevant parts of a divide-and-conquer strategy: (i) divide, (ii) conquer, and (iii) combine. (b) Establish the recurrence relation for the running time, T(n), of DC_PROD. (c) Apply the Master Theorem to give a tight bound for T(n).
Trace the search of element 43 in the list given using linear search and binary search. {2, 4, 7, 10, 11, 43, 50, 59, 60, 66, 69, 70, 79} {2, 8, 10, 12, 18, 20, 22, 28, 30, 34, 38, 40, 50} Explain what happen when the search element is not found.
Question # 01: Consider the searching problem: Input: A sequence of n numbers A = (a1, a2, a3, an ) a value V. Output: An index i such that v = A[i] or the special value NIL if v does not appear in A. Write pseudocode for linear search, which scans through the sequence, looking for v. Using a loop invariant, prove that your algorithm is correct. Make sure that your loop invariant fulfills the three necessary properties.
Problem 7. You are given three sorted sequences of lg n, n and n² keys respectively. Let these sequences be denoted by A, B, C respectively. You are asked to generate an array D that contains all the keys that are common to all three sets A, B, C, i.e. de D if and only if de A and d E B and d e C. How fast can you find and generate D? Explain by providing an efficient algorithm; analyze its worst-case running time.
D and e
Question 2: Recurrences (a) Below is the pseudo-code for two algorithms: Practicel (A,s,f) and Practice2(A,s,f), which take as input a sorted array A, indexed from s to f. The algorithms make a call to Bsearch(A,s,f,k) which we saw in class. Determine the worst-case runtime recurrece for each algorithm: T1(n) and T2(n). Show that T(n) is O((log n)²) and T2(n) is O(n log n). Practicel (A,s,f) if s< f ql = L(s+ f)/2] if BSearch(A,s,ql,1) = true Practice2(A,s,f) if s < f if BSearch(A,s+1,f,1) = true return true return true else else return Practice2(A, s, f-1) return Practicel(A, ql+1, f) else else return false return false
Question A: Mapping. The two-sum problem is a popular algorithm problem. Given an array of integers and an integer target, return indices of the two numbers such that they add up to the target. You may assume that each input would have exactly one solution, and you may not use the same element twice. For example, suppose we have an array arr = [1,10,100]. If the target is 11, you should return [0,1] because arr[0] + arr[1] = 1+ 10 = 11. If the target is 101, you should return [0,2] because arr[0] + arr[2] = 1+ 100 = 101. Complete this problem in O(n). Hint: using a hash table.