The following Prefix_Average algorithm needs O(n-logn).

PYTHON def _insertionsort(self, order):    # Implements the insertion sort algorithm to sort a list of items in ascending or descending order    n = len(self.items)    for i in range(1, n):        key = self.items[i]        j = i - 1        if order == 'asc':            while j >= 0 and key < self.items[j]:                self.items[j + 1] = self.items[j]                j -= 1            self.items[j + 1] = key        elif order == 'desc':            while j >= 0 and key > self.items[j]:                self.items[j + 1] = self.items[j]                j -= 1            self.items[j + 1] = key  def sort(self, order = 'asc', type = 'insertion'):          if type == 'insertion':            # call the insertions sort method to sort atos array based on the parameter values            #######################################################################

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 1 Euclid1(a,b)Require: a, b > 0Ensure: a = GCD(a, b)    while a ̸= b do        if a > b then            a ← a − b        else            b ← b − a        end if    end whilereturn a We want to prove the correctness of this algorithm using the loop invariant technique. a. In a first attempt to prove the correctness of this algorithm, we propose the following loop invariant property: “GCD(a, b) is a factor of a and b”. Explain why this property willnot help you as is. b. Use your previous observation to propose another loop invariant property that willhelp you to prove the correctness of the version of Euclid’s algorithm presented above.  c. Show that your loop invariant property is true before executing the While loop forthe first time (i.e., initialization property)

Fermat's "Little" Theorem states that whenever n is prime and a is an integer, a^n−1≡1modn Then 281825≡ 263 mod827. c) If a=146 and n=331, then efficiently compute 146332≡ mod331Use The Extended Euclidean Algorithm to compute281^1≡362 mod827. Then 281^825≡???mod827. c) If a=146 and n=331, then efficiently compute146^332≡ ???mod331

Code req positive integer decompose, find an algorithm to find the number ofnon-negative number division, or decomposition. The complexity is O(n^2). Example 1:Input: 4Output: 5Explaination:4=44=3+14=2+24=2+1+14=1+1+1+1 Example :Input: 7Output: 15Explaination:7=77=6+17=5+27=5+1+17=4+37=4+2+17=4+1+1+17=3+3+17=3+2+27=3+2+1+17=3+1+1+1+17=2+2+2+17=2+2+1+1+17=2+1+1+1+1+17=1+1+1+1+1+1+1.

Algorithm

Suppose you have an algorithm that operates on a set of data with n elements. If the recurrence formula that computes the time requirement for the algorithm is given by T(n) = 87 (C (1) + Dn a. nlgn b. n² lg n c. n² d. n³ e. if n > 1 if n = 1 where D and C are constants, which of the following gives the order of complexity of the algorithm? none of the other answers

Below is pseudocode representing the Compute-Opt algorithm: Compute-Opt(j):    If j = 0 then        Return 0    Else        Return max(vj+Compute-Opt(p(j)), Compute-Opt(j − 1))    Endif Memoization of this algorithm does what to its running time? Group of answer choices It reduces the running time from exponential to linear. It reduces the running time from O(n2) to O(n). It reduces the running time from exponential to O(n log n). It doesn't significantly reduce the running time, but it enables the algorithm to utilize less space.

Consider the following recursive algorithm, where // denotes integer division: 3//2 = 1, 5//2 = 2, etc. F(n):if n <= 1:    returnF(n//2)for i from 0 to n    for j from 0 to n//2        print(i+j)    Let function T(n) denote the running time of this algorithm. Derive T(n) and prove its worst case timecomplexity