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

solution should have O(l1.length + l2.length) time complexity, since this is what you will be asked to accomplish in an interview. Given two singly linked lists sorted in non-decreasing order, your task is to merge them. In other words, return a singly linked list, also sorted in non-decreasing order, that contains the elements from both original lists.
Consider the QuickSelect. This algorithm solves the problem of finding k-th smallest value in a given list A with length n. Below is a summary of the pseudocode for QuickSelect:(1) Pick a pivot element p at random from A and Split A into subarrays left and right by comparing each element to p as in Quicksort. While we are at it, count the number L of elements going in to left.
Consider an unordered list of data pieces L[0:5] = 23, 14, 98, 45, 67, 53. Let's look for the key K = 53. Obviously, the search proceeds along the list, comparing key K with each element until it finds it as the final member in the list. In the instance of looking for the key K = 110, the search proceeds but falls off the list, declaring it failed. Create Algorithm Procedures for both sorted and unordered linear searches, as well as their times.
Consider a (singly) linked list. Describe an algorithm to remove every second elementfrom the list.(HINT: The algorithm is similar to the one that is used when we delete a single node. Here,we need to skip an element after every deletion, and then if we have not reached the end ofthe list repeat this procedure until the list is exhausted.).
Given an unsorted array of integers, find the length oflongest increasing subsequence.Example:Input: [10,9,2,5,3,7,101,18]Output: 4Explanation: The longest increasing subsequence is [2,3,7,101], therefore thelength is 4.Time complexity:First algorithm is O(n^2).Second algorithm is O(nlogx) where x is the max element in the listThird algorithm is O(nlogn)Space complexity:First algorithm is O(n)Second algorithm is O(x) where x is the max element in the listThird algorithm is O(n)""" def longest_increasing_subsequence(sequence): """ Dynamic Programming Algorithm for counting the length of longest increasing subsequence type sequence: list[int] rtype: int """ length = len(sequence) counts = [1 for _ in range(length)] for i in range(1, length): for j in range(0, i): if sequence[i] > sequence[j]: counts[i] = max(counts[i], counts[j] + 1) print(counts) return max(counts) def…
For the 8-queens problem, define a heuristic function, design a Best First Search algorithm in which the search process is guided by f(n) = g(n) + h(n), where g(n) is the depth of node n and h(n) is the heuristic function you define, and give the pseudo code description.
illustrates the search procedure on a skip list S for a key K. The algorithm employs functions next(p) and below(p) to undertake the search. Write code with explaination otherwise you will get downvote
A sequential search of a sorted list can halt when the target is less than a givenelement in the list. Define a modified version of this algorithm and state thecomputational complexity, using big-O notation, of its best-, worst-, and average-case performances. Using this template in python: def sequential_search(input_list, target):target_index = -1#TODO: Your work here# Return target_index. If not found, -1return target_indexif __name__ == "__main__":my_list = [1, 2, 3, 4, 5]print(sequential_search(my_list, 3)) # Correct Output: 2print(sequential_search(my_list, 0)) # Correct Output: -1
This assignment is an exercise in finding the average-case complexity of an algorithm.Rather than looking at how long an algorithm can run in the worst case as in worst-case analysis, we are looking at how long an algorithm runs on average. This is doneby computing the average number of comparisons and operations executed until thealgorithm ends.Bogosort is a sorting algorithm that orders a list in increasing order by taking thelist, checking to see if the list is ordered increasingly, if the list is not ordered increasinglythen the list is randomly shuffled, and then repeating this process until the list is orderedincreasingly.Expressed in pseudocode:Algorithm 1 BogosortRequire: list: a1, a2, . . . , an of real numbersEnsure: list is sorted in increasing order1: procedure bogo(list)2: while not sorted(list) do ▷ Checks to see if list is sorted3: shuffle(list) ▷ Shuffle the current list if not sorted4: end while5: end procedure Problem: Consider the Bernoulli trial where a success is…
Algorithm Linear Search Input: L = a1, a2, ... , an list of distinct integers; x integer Output: p integer i = 1; found = F; p = 0; while i ≤ n and found = F if ai = x then found = T and p = i else i = i+1; return p; When performing Algorithm Linear Search with input L = 1,3,5,7,9,11,13 and x = 7, x is compared to an element ai of the list L exactly 3 times. Group of answer choices True False
Consider a list of data components L[0:5] = 23, 14, 98, 45, 67, and 53. Let's look for the K = 53 key. Naturally, the search moves down the list, comparing key K with each element until it discovers it as the final element in the list. When looking for the key K = 110, the search moves forward but eventually drops off the list, making it a failed search. Write the algorithmic steps for both sorted and unordered linear searches, along with the times involved.
Computer Science Write the PSEUDOCODE for an algorithm that takes as input a list of numbers that are sorted in nondecreasing order, and finds the location(s) of the most frequently occurring element(s) in the list. If there are more than one element that is the most frequently occurring, then return the locations of all of them. Analyze the worst-case time complexity of this algorithm and give the O() estimate. (A list is in nondecreasing order if each number in the list is greater than or equal to the number preceding it.)