Prove that the outer loop for this algorithm is correct, using the following steps. You may assume for simplicity that the inner while loop is correct (i.e., it inserts the element A[j] in its proper position of the sub-array A[1..j]). Given the following pre-condition, loop invariant, and post-condition: • Pre-condition: A[1..n] is an array of integers. • Loop invariant: at the start of each iteration, the sub-array A[1..j – 1] consists of the elements originally in A[1..j – 1], but in sorted order. • Post-condition: the array A[1..n] consists of the elements originally in A[1..n], but in sorted order. Prove the following: • Initialization: If the pre-condition is true, then the loop invariant is initially true (prior to the first iteration of the loop). • Maintenance: If the loop invariant is true before an iteration, it remain true before the next iteration. • Termination: The loop will eventually terminate. And when it does, the loop invariant implies the post-condition. 1: for j=2: A.length do key = A[j] i = j – 1 while i > 0 and A[i] > key do A[i + 1] = A[i] i = i – 1 A[i + 1] = key 2: 3: 4: 5: 6: 7:

Prove that the outer loop for this algorithm is correct, using the following steps. You may assume for simplicity that the inner while loop is correct (i.e., it inserts the element A[j] in its proper position of the sub-array A[1..j]). Given the following pre-condition, loop invariant, and post-condition: • Pre-condition: A[1..n] is an array of integers. • Loop invariant: at the start of each iteration, the sub-array A[1..j – 1] consists of the elements originally in A[1..j – 1], but in sorted order. • Post-condition: the array A[1..n] consists of the elements originally in A[1..n], but in sorted order. Prove the following: • Initialization: If the pre-condition is true, then the loop invariant is initially true (prior to the first iteration of the loop). • Maintenance: If the loop invariant is true before an iteration, it remain true before the next iteration. • Termination: The loop will eventually terminate. And when it does, the loop invariant implies the post-condition. 1: for j=2: A.length do key = A[j] i = j – 1 while i > 0 and A[i] > key do A[i + 1] = A[i] i = i – 1 A[i + 1] = key 2: 3: 4: 5: 6: 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

1. Consider the algorithm for the sorting problem that sorts an array by counting,for each of its elements, the number of smaller elements and then uses thisinformation to put the element in its appropriate position in the sorted array:ALGORITHMComparisonCountingSort(A[0..n − 1])//Sorts an array by comparison counting//Input: Array A[0..n//Output: Array S[0..n− 1] of orderable values− 1] of A’s elements sorted// in nondecreasing orderfor i ← 0 to nCount− 1 do[i]←0for i ← 0 to n − 2 dofor j ← i +1 to n − 1 doif A[i] < A[j ]Count[j ]← Count[j ] + 1else Count[i]← Count[i] + 1for i ←0 to n−1 doS[Count[i]]←A[i]return Sa. Apply this algorithm to sorting the list 60, 35, 81, 98, 14, 47.b. Is this algorithm stable?c. Is it in-place?
Given an unsorted array A of integers of any size, n ≥ 3, and an integer value x, write an algorithm as a pseudo code (not a program!) that would find out if there exist EXACTLY3 occurrences in the array with value x. What is the time complexity of your algorithm, in terms of Big-O? What is the space complexity of your algorithm, in terms of Big-O? What if , the given array A is sorted. Will time complexity change from the case that A was unsorted? • If yes; give a new algorithm that achieves this better complexity (indicate the time complexity as of that algorithm). • If no, explain why such new constraints/conditions cannot lead to a better time complexity.
The recursive algorithm below takes as input an array A of distinct integers, indexed between s andf, and an integer k. The algorithm returns the index of the integer k in the array A, or ?1 if the integerk is not contained within A. Complete the missing portion of the algorithm in such a way that you makethree recursive calls to subarrays of approximately one third the size of A.• Write and justify a recurrence for the runtime T(n) of the above algorithm.• Use the recursion tree to show that the algorithm runs in time O(n).FindK(A,s,f,k)if s < fif f = s + 1if k = A[s] return sif k = A[f] return felseq1 = b(2s + f)=3cq2 = b(q1 + 1 + f)=2c... to be continued.else... to be continued.
Write an efficient algorithm (to the best of your knowledge) for the following problem, briefly describe why it is a correct algorithm, and analyze the time complexity. If you cannot find any polynomial-time algorithm, then give a backtracking algorithm. Problem: Repeated Number Input: An array A[1...3n] of positive integers. Output: If any number in the array appears at least n times, then print such a number. Otherwise, print 'none'. Example: Input: A = [1,3,3,3,1,1]. Here 3n = 6 and n =2. Output: 3. Note that here 1 would also be a valid output. You just need to print one if there are many options. Example: Input: A = [4,3,5,7,9,1]. Here 3n = 6 and n =2. Output: 'none'
s algorithm for finding all occurrences of a sequence in anothersequence using the suffix array of the latter sequence can be implemented inPerl in a straightforward way, as shown in the following Perl script. Recallthat the suffix array of a sequence of length n will be a permutation of arraypositions 0, 1, . . . , n − 1, because Perl arrays do not start with position 1 but,rather, with position 0.
Let A and B be two arrays of length n, each containing a random permutation of the numbers from 1 to n. An inversion between the two permutations A and B is a pair of values (x, y) where the index of x is less than the index of y in array A, but the index of x is more than the index of y in array B. Design an algorithm which counts the total number of inversions between A and B that runs in O(n log n) time.
Write an algorithm that, given an array, initialises all the elements so that thecontent of each element is the index (i.e. A[i] contains i), then multiplies all theelements of the array together to give the result.
please answer briefly thanks Analyze the worst-case time complexity of the bottom algorithms that I generated in the question 1 Assume the length of the input sequence is n. Do not use Big-O notation. question 1, Analysis of the algorithm in part 1 array = {elements in given sequence} pair_ele1 = array[0] pair_ele2 = array[1] n = length(array) for(i=0;i<n;i++) { for(j=i+1;j<n;j++){ if((array[i]+array[j])>(pair_ele1+pair_ele2)){ pair_ele1 = array[i]; pair_ele2 = array[j]; } } } print("Largest Sum = ",(pair_ele1)+(pair_ele2))
Write out the algorithm (pseudocode) to find K in the ordered array by the method that compares K to every fifth entry until K itself or an entry larger than K is found, and then, in the latter case, searches for K among the preceding four. How many comparisons does your algorithm do in the worst case?
: In searching an element in an array, linear search can be used, even though simple to implement, but not efficient, with only O(n) time complexity. Assuming the array is already in sorted order, modify the search function below, using a better algorithm, so the average time complexity for the search function is O(log n). include <iostream> using namespace std; int search(int al), int s, int v) { 1/ Modify below codes. for (int i = 0; i <s; i++) { if (a[i] = v) return i; return -1; int main() { int intArray:10] = { 5, 7, 8, 9, 10, 12, 13, 15, 20, 34); // Search for element '12' in 10-elements integer array. cout << search(intArray, 10, 12); // '5' will be printed out. // Search for element '35' in 10-elements integer array. cout << search(intArray, 10, 35); // '-1' will be printed out. // Index '-l' means that the element is not found. return 0;
Implement an algorithm that returns the X closest items to a value V, for any array of integer elements. V may or may not be present in the array. Its solution must be O(nlogn). (phyton or Java). Note: The proposed solution must use the divide-and-conquer strategy.
Write an efficient algorithm for the following problem, and describe your reasoning. Determine the Time complexity and if you cannot find any polynomial time algorithm, then give a backtracking algorithm. Problem: Binary Array Core Input: Two integers p and q and a binary array A[1...n], i.e., each entry contains either a 0 or 1. Output: Print Yes - if there exists a subarray A[i...k], where 1<= i < k <= n, with exactly p zeros in A[1...i-1] (there may be 1s) and exactly q ones in A[k+1...n] (there may be 0s). Print No - otherwise. Outputs with examples Input: A = [0,1,1,0,1], p = 2, q =1, Output: No. Input: A = [0, 1,1,0, 0,1,0,1], p = 1, q =1, Output: Yes because we can have A[1...i-1] = [0] and A[k+1 ... n] = [0,1,0,1]