Text reading is an integral component in our counting algorithms, and it is also ubiquitous in daily applications. The following is a very bad algorithm for reading from a text file, although it is correct and straightforward. It reads from a file line by line, and concatenate them into text. Then we split it using a regular expression. The split part is fast in linear complexity (we will learn it in Comp-2140), hence that is not our concern. Note that trim() is needed to remove empty strings. static String [] readTextBAD(String PATH) throws Exception { BufferedReader br=new BufferedReader (new FileReader(PATH)); String text=""; String line=""; while ((line=br.readLine ())!=null) text=text+" "+line.trim(); String tokens []=text.trim ().split("[^a-zA-Z]+"); return tokens; } Timo oomplovitu of nogdT +RAD

Text reading is an integral component in our counting algorithms, and it is also ubiquitous in daily applications. The following is a very bad algorithm for reading from a text file, although it is correct and straightforward. It reads from a file line by line, and concatenate them into text. Then we split it using a regular expression. The split part is fast in linear complexity (we will learn it in Comp-2140), hence that is not our concern. Note that trim() is needed to remove empty strings. static String [] readTextBAD(String PATH) throws Exception { BufferedReader br=new BufferedReader (new FileReader(PATH)); String text=""; String line=""; while ((line=br.readLine ())!=null) text=text+" "+line.trim(); String tokens []=text.trim ().split("[^a-zA-Z]+"); return tokens; } Timo oomplovitu of nogdT +RAD

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

Consider a divide-and-conquer algorithm that calculates the sum of all elements in a set of n numbers by dividing the set into two sets of n/2 numbers each, finding the sum of each of the two subsets recursively, and then adding the result. What is the recurrence relation for the number of operations required for this algorithm? Answer is f(n) = 2 f(n/2) + 1. Please show why this is the case.
Please explai Which algorithm has a better Big-O complexity heapsort or merge sort? Group of answer choices a. Merge Sort b. Heap sort c. They have equal Big-O complexities
Consider the 3-Merge sort algorithm, which recursively divides an array of length>=3 into 3 subarrays of equal size and sort each of them recursively(via 3-Merge sort) then uses the above merge method to obtain a sorted array. Does 3-Merge sort perfom asymptotically better than the classical Merge Sort algorithm and why?
Design an experiment to compare different algorithms for the selection problem, i.e. findingk’th smallest element in an unsorted list of n numbers. There are following candidatemethods: (i) Sort all elements by Insertion-sort and return the ?’th element in the list,(ii) Sort all elements by Merge-sort and return the ?’th element in the list,
Deal a hand of thirteen playing cards and sort it using the merge sort procedure described in the text. Use this experience to defend the notion that, even though merge sorting may be computationally superior, selection sorting still has its place.
Deal a hand of thirteen playing cards and sort it using the merge sort procedure described in the text. Use this experience to defend the notion that, even though merge sorting may be computationally superior, selec tion sorting still has its place.
Consider the following variation of mergesort:(a) If n ≤ 1, we are done.(b) Divide the n elements into b subarrays of n/b elements each.(c) Recursively call mergesort to sort each of the b subarrays.(d) Merge the b sorted subarrays.For example, the standard mergesort has b = 2, and merging takes Θ(n) comparisons.If b = 3, then we have a 3-way mergesort, and one can show that it takes Θ(n) comparisons to merge 3 sorted lists. In fact, one may show that merging b sorted lists (for any fixed b) can be done in Θ(n) comparisons.Now consider the following argument: if we set b = n, we recursively sort n subarrays of size 1, and then merge them into one list with Θ(n) comparisons. Thus, the complexitycan be expressed by:T(1) = 0T(n) = nT(1) + Θ(n) = Θ(n)Therefore, this variation of mergesort sorts an array in Θ(n) comparisons.What is wrong with this argument? Hint: think about how to implement this variation.
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
Consider median-3 quick sort and bubble sort. When using these two algorithms to sort a list of n elements that have already been sorted in increasing order, which of the following is true for the worst-case time complexity?
Q2: Recall the problem of finding the median of an array of an unsorted list. How fast can one complete the median? What is the recurrence relation that the algorithm follows? (Do not state the algorithm or solve the recurrence relation)
does increasing the number of partitions of the merge sort function worsen its time complexity? Example: Original recurrence relation: T(n)=2T(n/2) New recurrence relation: T(n)=4T(n/2) provide a simple explanation aside from master's theorem.
Given an array A and two indices p and r consider the following modified merge sort algorithm write a recurrence relation describing the running time of algorithm modified merge sort(A, p,r) include base case. mofified merge sort (A, p, r) if p<r n = r - p + 1 q = n/3 foo(A,p,p + q) foo (A,p, + q + 1, p + 2q) foo(A, P + 2q + 1, r) merge (A, p, p + q, p + 2q) merge(A, p,p + 2q,r)