1. The big-O complexity of a nested array is 2. The best-case complexity of binary search is a. 0 (n²) b. 0 (log n) c. O(n) d. 0 (1) 3. The polynomial big-O complexity is mathematically represented by 4. The worst-case complexity of linear search is 5. In changing money, greedy choice is not always optimal. True / False 6. To estimate the time when a professor enters the classroom can be done using the order notation 7. The limiting behavior of a function when the argument tends towards infinity is called 8. The problem with recursive change algorithm is that

1. The big-O complexity of a nested array is 2. The best-case complexity of binary search is a. 0 (n²) b. 0 (log n) c. O(n) d. 0 (1) 3. The polynomial big-O complexity is mathematically represented by 4. The worst-case complexity of linear search is 5. In changing money, greedy choice is not always optimal. True / False 6. To estimate the time when a professor enters the classroom can be done using the order notation 7. The limiting behavior of a function when the argument tends towards infinity is called 8. The problem with recursive change algorithm is that

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 two algorithms for the same problem: • Algorithm A, which runs in O(n) and produces a correct answer with probability 0.7, and a wrong answer with probability 0.3. • Algorithm B, which runs in O(n log n) and produces a correct answer with probability 0.99, and a wrong answer with probability 0.01. Which of the two algorithms should you use to build a more asymptotically (in n) efficient algorithm with probability 0.99 of producing a correct answer? Justify. Assume that you can always check if an answer is correct in constant time.
Second order Spada numbers are well established in the insurance industry. Formally they are defined by the recurrence: Si={Si−1 %( Si−2+1) :i≥ 2 , 1:i=0 ,7 :i=1} Give an O(n) time algorithm to compute the n-th Second order Spada number
The average time complexity for an algorithm can be found by adding the best time and worst time and dividing that answer by 2. O True False
An NP-complete problem is a fascinating kind of problem because till now no one has discovered the polynomial-time algorithm to solve it and also no one has proved that no polynomial-time algorithm can exist for any NP-complete problem. It is an open research problem since it was first posed in 1971 to prove P#NP. The NxN Queens problem can be summarized as follows: putting N chess queens on an N×N chessboard such that none of them is able to attack any other queen using the standard chess queen's moves (row-column- diagonal). Thus, a solution requires that no two queens share the same row, column, or diagonal. Solutions exist only for N = 1 or N 2 4. Use the given function below to test whether a queen is attacked by another or not. You are not allowed to use any other code to check if a queen is safe. Implement a backtracking solution for the algorithm in Java that finds all possible solutions for N queens and measure the execution time it takes for N=4 to 12 and compare them…
Data Structyre and Algorithms: Solve solve this on emergency basis: find running Time complexity T(n) and Space complexity S(n). Also show in big-O notation. Code Segment 6 Algorithm MultiplyMatrix for(i = 0; i < n; ++i) for(j = 0; j < n; ++j) C[i][j]=0; for(k = 0; k < n; ++k) { c[i][j] = c[i][j] + a[i][k] * b[k][j]; }
not handwritten Design a divide and conquer algorithm to solve the following problem in Θ(n log n) time: You are given a sequence A[1..n] of n numbers. Find i and j with i < j that maximizes A[j] − A[i].
The heuristic function of greedy best-first search is Select one: a. f(n) > h(n) b. f(n) < h(n) c. f(n) = h(n) d. f(n) != h(n)
Match each algorithm below with the tightest asymptotic upper bound for its worst-case running time by inserting one of the letters A, B, C, D, and E into the corresponding box. For sorting algorithms, n is the number of input elements. For matrix algorithms, the input matrix has size n X n. For graph algorithms, the number of vertices is n, and the number of edges is 0(n). Insertion Sort Heapsort Depth-first search (for the adjacency list representation) Floyd-Warshall Strassen's O(n^log7) O(n) O(n logn) O(n^2) O(n^3) O(1) O(n^4) ㅇ(logn)
The algorithm of Euclid computes the greatest common divisor (GCD) of two integer numbers a and b. The following pseudo-code is the original version of this algorithm. Algorithm Euclid(a,b)Require: a, b ≥ 0Ensure: a = GCD(a, b) while b ̸= 0 do t ← b b ← a mod b a ← tend whilereturn a What is the maximum number of iterations of the While loop the algorithm will do?
Voting Suppose that the votes of n people for different candidates (where there can be more than two candidates) for a particular office are the elements of a sequence. A person wins the election if this person receives a majority of the votes. 9. (a) Devise a divide-and-conquer algorithm that determines whether a candidate received a majority and, if so, determine who this candidate is. (b) Devise a divide-and-conquer algorithm that determines whether the two candidates who received the most votes each received at least n/4 votes and, if so, determine who these two candidates are. (c) Give a big-O estimate for the number of comparisons needed by the algorithm you devised in part (a).
Consider array A of n numbers. We want to design a dynamic programming algorithm to find the maximum sum of consecutive numbers with at least one number. Clearly, if all numbers are positive, the maximum will be the sum of all the numbers. On the other hand, if all of them are negative, the maximum will be the largest negative number. The complexity of your dynamic programming algorithm must be O(n2). However, the running time of the most efficient algorithm is O(n). Design the most efficient algorithm you can and answer the following questions based on it. To get the full points you should design the O(n) algorithm. However, if you cannot do that, still answer the following questions based on your algorithm and you will get partial credit. Write the recursion that computes the optimal solution recursively based on the solu- (a) tion(s) to subproblem(s). Briefly explain how it computes the solution. Do not forget the base case(s) of your recursion.
Algorithm Bellman_Ford1: procedure Bellman_Ford(G,s)2: for all {v} ∈ V do initialize3: d[v]←∞4: p[v] ← Ø5: end for6: d[s] ← 0 s has 0 cost7: for k = 1 to n − 1 do8: for all (u, v) ∈ E do relaxation9: if d[v] > d[u] + w[u, v] then10: d[v] = d[u] + w[u, v]11: p[v] ← u12: end if13: end for14: end for15: for all (u, v) ∈ E do16: if d[v] > d[u] + W[u, v] then17: return Ø a negative cycle detected18: end if19: end for20: return d, P21: end procedure Make Python Implementation of given algorithm