Complexity The function accumulate operates on a list of n integers where each element was chosen inde- pendently from the set {1, 2, ..., 8} with uniform probability. In analyzing the running time of this code, we are only interested in the number of explicit assignment statements (lines 1, 4 and 8) not the loop controls. Your answers should be in terms of n and give actual values not asymptotic classes. Arrays are using 1-based indexing. def accumulate(A): 1 sum = 2 for i in 1 to n: #1-based indexing 3 if A[i] < 7: 4 sum = sum +A|i] else: 5 for j in 1 to n: for k in 1 to j: sum = sum + A[i]/A[j] 7 8 10 return sum (b) Worst Case Prove a worst-case analysis being careful to provide all the required pieces. Give an exact count of the operations of interest (total count of lines 1, 4 and 8), not an asymptotic bound. (c) Average case Give a formula for the total number of assignment statements (Lines #1, #4, and #8) executed in the average case. Explain each term in your formula so the reader can see the justification. You do not need to simplify the equation.

Complexity The function accumulate operates on a list of n integers where each element was chosen inde- pendently from the set {1, 2, ..., 8} with uniform probability. In analyzing the running time of this code, we are only interested in the number of explicit assignment statements (lines 1, 4 and 8) not the loop controls. Your answers should be in terms of n and give actual values not asymptotic classes. Arrays are using 1-based indexing. def accumulate(A): 1 sum = 2 for i in 1 to n: #1-based indexing 3 if A[i] < 7: 4 sum = sum +A|i] else: 5 for j in 1 to n: for k in 1 to j: sum = sum + A[i]/A[j] 7 8 10 return sum (b) Worst Case Prove a worst-case analysis being careful to provide all the required pieces. Give an exact count of the operations of interest (total count of lines 1, 4 and 8), not an asymptotic bound. (c) Average case Give a formula for the total number of assignment statements (Lines #1, #4, and #8) executed in the average case. Explain each term in your formula so the reader can see the justification. You do not need to simplify the equation.

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

The SparseVector class should be extended to include a method sum() that accepts a SparseVector as an argument and returns a SparseVector that represents the term-by-term total of the input and output vectors. Note: To handle the situation where an entry becomes 0, you must use delete() (and pay close mind to precision).use java to code
You are given an integer n and an array of unique integers blacklist. Design an algorithm to pick a random integer in the range [0, n − 1] that is not in blacklist. Any integer that is in the mentioned range and not in blacklist should be equally likely to be returned. Optimize your algorithm such that it minimizes the number of calls to the built-in random function of your language.
By the "n queens problem" we mean the problem of placing n queens on an nXn “chessboard" in such a way that no queen can capture any other on the next move. In class we solved the "8 queens" problem. Write a function that inputs an integer n and returns the number of solutions to the “n queens" problem. Your function should use the one dimensional representation for the board, the algorithm we discussed in class, and no gotos. Test your function with a main program that prompts the user for an integer n. The main program then calls the function n times, once for each number from 1 – n, and then prints the number of solutions to each of these problems, one on a line. For example, if you enter n=5 your program should output: 1. There are 2. There are 3. There are 4. There are solutions to the 1 queens problem. solutions to the 2 queens problem. solutions to the 3 queens problem. solutions to the 4 queens problem. solutions to the 5 queens problem. 5. There are Now, since each time…
The insertion sort was discussed and the implementation was demonstrated in the sorting lecture. In this assignment, you are asked to re-implement the insertion sort (InsertionSort.java),with additional requirements. Particularly, you need to show:1. For each iteration, how a number from a unsorted region is placed in the correctionposion in the sorted region;2. How to make the whole array be sorted based on the previous step, and count the totalnumber of shifts during the whole insertion sort process.2 Details of the ProgramTo complete the whole implementation, you should write at least the following importantmethods:2.1 Part1: insertLast/**A method to make an almost sorted array into fully sorted.@param arr: an array of integers, with all the numbers are sortedexcepted the last one@param size: the number of elements in an array*/public static void insertLast(int[] arr, int size){// your work}To make it concrete, let’s use the example shown in Figure 1. In this example, the…
For each problem, please provide Describe the worst-case input (the input that would cause the largest running time) Summation used to calculate number of steps for the worst case Explanation of how the code relates to the summation a. (loops require discussing number of iterations and steps per iteration) b. (recursion requires a diagram) A O bound i. i. ii. iv. static Integer sum(List a) { if (a.size() == 0) { return 0; } else if (a.size() == 1) { return a.get(0); } else { a.size()/2; int rightLen = a.size() - leftLen; int leftLen List aLeft List aRight (); (); %3D new new %D for (int i=0; i
We will be looking at a problem known as the partition problem. The partition problem is to determineif a given set can be partitioned into two subsets such that the sum of elements in both subsets is thesame. This is a variant of the 0-1 knapsack problem.You would notice that the code only returns True or False. Suppose now you need to change thecode using Backtracking such that it returns the numbers of the subsets.Please explain your codes.# Returns true if there exists a sublist of list `nums[0…n)` with the given sum def subsetSum(nums, total): n = len(nums) # `T[i][j]` stores true if subset with sum `j` can be attained # using items up to first `i` items T = [[False for x in range(total + 1)] for y in range(n + 1)] # if the sum is zero for i in range(n + 1): T[i][0] = True # do for i'th item for i in range(1, n + 1): # consider all sum from 1 to total for j in range(1, total + 1): # don't include the…
Write and implement a recursive version of the binary search algorithm. Also, write a version of the sequential search algorithm that can be applied to sorted lists. Add this operation to the class orderedArrayListType for array-based lists. Moreover, write a test program to test your algorithm.
The function Ecol_M M in the Python programme that implements this approach discovers the minimum edge colours for a graph that is passed to it in the form of an incidence matrix. To discover the maximal matching in the graph, we utilise the Maximal Match function from the earlier constructed module MATCH within this function. The list edges is used to retain uncolored edges, while the list edge color is used to hold the current edge colours. The while loop continues to run until the edges list is empty, at which point all edges have been coloured. At each iteration, the graph is reduced by removing the columns associated with the matched edges.
You are given an array-like data structure Listy which lacks a size method. It does, however, have an elementAt ( i) method that returns the element at index i in 0( 1) time. If i is beyond the bounds of the data structure, it returns -1. (For this reason, the data structure only supports positive integers.) Given a Listy which contains sorted, positive integers, find the index at which an element x occurs. If x occurs multiple times, you may return any index. Write code with explanation
Suppose that intArray is an array of integers, and length specifies the number of elements in intArray. Also, suppose that low and high are two integers such that 0 <= low < length, 0 <= high < length, and low < high. That is, low and high are two indices in intArray. Write a recursive definition that reverses the elements in intArray between low and high.
There is an array with n integers, but the values are hidden to us. Our goal is to partition the elements in the same group should have the same value, 4. elements into groups based on their values while elements in different groups have different values. The values are hidden to us so you cannot directly call for a value, like Arr[i]. However, we can probe the array by calling the function query(). The function takes a subset of elements as inputs and returns the number of unique integers in this subset. Design an algorithm to partition these n elements in O(nlog n) queries. (query() is called O(nlog n) times)
Implement a recursive function void deleteMax() on the IntList class (provided). The function will delete from the IntList the IntNode containing the largest value. If there are multiple nodes containing this largest value, only delete the 1st one. Be careful not to cause any memory leaks or dangling pointers. You may NOT use any kind of loop (must use recursion). You may NOT use global or static variables. You may NOT use any standard library functions. Ex: list: 5->7->1->16->4->16->3 list.deleteMax(); list: 5->7->1->4->16->3 IntList.h #ifndef __INTLIST_H__#define __INTLIST_H__ #include <ostream> using namespace std; struct IntNode {int value;IntNode *next;IntNode(int value) : value(value), next(nullptr) {}}; class IntList { private:IntNode *head; public: /* Initializes an empty list.*/IntList() : head(nullptr) {} /* Inserts a data value to the front of the list.*/void push_front(int val) {if (!head) {head = new IntNode(val);} else {IntNode…