Suppose you have m sorted arrays, each with n elements, and you want to combine them into a single sorted array with mn elements. 1. If you do this by merging the first two arrays, next with the third, then with the fourth, until in the end with the last one. What is the time complexity of this algorithm, in terms of m and n? 2. Give a more efficient solution to this problem, using divide-and-conquer. What is the running time?

Suppose we have an O(n) time algorithm that finds the median of an unsorted array. Now consider a QuickSort implementation where we first find median using the above algorithm, then use median as the pivot. What will be the worst-case time complexity of this modified QuickSort? (A) O(n^2 Logn) (B) O(n^2) (C) O(n Logn Logn) (D) O(nLogn) (E) O(n)

Find the running time for each of the following algorithms. Show work by finding a table of values for each while loop, writing the summations, then solving. Be sure to show work on both the upper bound and lower bound, justify the split, and check that the bounds differ by only a constant factor. Use asymptotic notation to write the answer. a) Func2(n) 1 2 3 4 5 6 7 S ← 0; j←7n²; while (j > 8) do s+ s + i- j; je lj/9]; end return (s);

In Python: Let n be a (large) positive integer of your choice. We want to know which of the two Quicksort algorithms methods (he Lomuto method and the Hoare method) is superior when sorting arrays containing n elements. To answer this question, you will run Quicksort on 10000 random permutations of [1,2,3, . . . , n], on each of your two Quicksort algorithms.

Given an unsorted array of integers, write a function in Python to find the length of the longest increasing subsequence (LIS) in the array. For example, given the array [10, 9, 2, 5, 3, 7, 101, 18], the LIS is [2, 3, 7, 101], which has a length of 4. Your solution should have a time complexity of O(n log n), where n is the length of the input array. Here's some code to get you started: def longest increasing_subsequence(arr): # TODO: implement function pass # example usage arr = [10, 9, 2, 5, 3, 7, 101, 18] print(longest_increasing_subsequence(arr)) # should print 4

You are given two sorted arrays  A = [1, 2, 3] B = [2, 5, 6, 7], o/p = [1, 2, 2, 3, 5, 6, 7] Write an algorithm to merge these sorted arrays. Mention the time and space complexity of your algorithm

Given an array A = [10, 7, 4, 2, 1], and target = 7, return the index of the target if found, else return -1. 1. Can this problem be solved in O(logN)?  2. If so, write the implementation. Mention time and space complexity 3. If this problem cannot be solved using O(logN), what is the solution that you suggest - write the code and also mention time and space complexity.

Problem 2. Suppose we have an array A[1 : n] which consists of numbers {1,...,n} written in some arbitrary order (this means that A is a permutation of the set {1,...,n}). Our goal in this problem is to design a very fast randomized algorithm that can find an index i in this array such that A[i] mod 8 € {1,2}, i.e., the reminder of dividing A[i] by 8 is either 1 or 2. For simplicity, in the following, we assume that n itself is a multiple of 8 and is at least 8 (so a correct answer always exist). For instance, if n = 8 and the array is A = [8,7, 2,5, 4, 6,3, 1], we want to output either of indices 3 or 8. (a) Suppose we sample an index i from {1,...,n} uniformly at random. What is the probability that i is a correct answer, i.e., A[i] mod 8 E {1,2}? (b) Suppose we sample m indices from {1,...,n} uniformly at random and with repetition. What is the probability that none of these indices is a correct answer? Now, consider the following simple algorithm for this problem: Find-Index-1(A[1:…