Consider a recursive function, called f, that computes powers of 3 using only the + operator. Assume n > = 0. int f(int n) { if (n == 0) return 1; return f(n-1) + f(n-1) + f(n-1); } Give an optimized version of f, called g, where we save the result of the recursive call to a temporary variable t, then return t+t+t. i got int g(int n) { if (n == 0) return 1; int t = g(n - 1); return t+t+t; } so now Write a recurrence relation for T(n), the number addition operations performed by g(n) in terms of n.

One remarkably simple formula for calculating the value of p is the so-called Madhava-Leibniz series: p4 =わ 1-ひく13+たす15-ひく17+たす19-.... Consider the recursive function below to calculate the first n terms of this formula: double computePI(int n) { if (n <= 1) { return 1.0;} int oddnum = 2 * n - 1; if ((n % 2) == 0 { } return -1.0 oddnum + computePI(n − 1); } else { } return 1.0 / oddnum + computePI (n - 1); Which statements about the run-time performance of this function are true? 1.Each time this function is called it will invoke at least two more recursive calls II.The number of recursive calls this function will make is approximately equal to the value of the parameter variable n III.Not counting overhead, this function will be about as efficient as an iterative implementation of the same formula

Write a recursive method that returns the value of N! (N factorial) using the definition given in this chapter. Explain why you would not normally use recursion to solve this problem.

Question: First write a function mulByDigit :: Int -> BigInt -> BigInt which takes an integer digit and a big integer, and returns the big integer list which is the result of multiplying the big integer with the digit. You should get the following behavior: ghci> mulByDigit 9 [9,9,9,9] [8,9,9,9,1] Your implementation should not be recursive. Now, using mulByDigit, fill in the implementation of bigMul :: BigInt -> BigInt -> BigInt Again, you have to fill in implementations for f , base , args only. Once you are done, you should get the following behavior at the prompt: ghci> bigMul [9,9,9,9] [9,9,9,9] [9,9,9,8,0,0,0,1] ghci> bigMul [9,9,9,9,9] [9,9,9,9,9] [9,9,9,9,8,0,0,0,0,1] ghci> bigMul [4,3,7,2] [1,6,3,2,9] [7,1,3,9,0,3,8,8] ghci> bigMul [9,9,9,9] [0] [] Your implementation should not be recursive. Code: import Prelude hiding (replicate, sum)import Data.List (foldl') foldLeft :: (a -> b -> a) -> a -> [b] -> afoldLeft =...

Write a program called p3.py that contains a function called reveal_recursive() that takes a word (string) and the length of the word (int) as input and has the following functionality: 1. prints the word where all characters are replaced by underscores 2. continue to print the word revealing one character at a time. i.e., the second line printed should print the first character followed by "_"’s representing the rest of the word. (see example below) 3. the function should end after printing the entire word once. 4. This function should be recursive Example: #the word is kangaroo ________ k_______ ka______ kan_____ kang____ kanga___ kangar__ kangaro_ kangaroo

Implement a function rollsToRepeat in Python that simulates a dice game in which a pair of dice are rolled repeatedly until some total on the dice occurs the specified number of times. Details: accepts one integer argument, n , the number of repeats required before the game ends rolls a pair of dice repeatedly until some dice total has repeated n times returns the total number of times the pair of dice was rolled For example, using a random seed of 85 , the sequence of rolled pairs will be : (2, 6), (5, 1),(3, 2), (2, 4), (3, 5), (2, 6), (4, 5), (5, 2), (6, 5), (5, 5), ... If you runrollsToRepeat with n=1 , only 1 repeat is required. On the first roll, the total 8=2+6 is repeated once (as wouldany first roll). So the simulation stops and the function returns 1. This always happens whenn=1 . n=2 , some total must repeat twice. This first occurs on the 4throll, when the total of 6occurs for the 2ndtime. n=3 , some total must repeat three times. This first occurs on the 6throll, when...

mplement a Java program that applies the Newton-Raphson's method xn+1 = xn – f(xn) / f '(xn) to search the roots for this polynomial function ax6 – bx5 + cx4 – dx3+ ex2 – fx + g = 0. Fill out a, b, c, d, e, f, and g using the first 7 digits of your ID, respectively. For example, if ID is 4759284, the polynomial function would be 4x6 – 7x5 + 5x4 – 9x3+ 2x2 – 8x + 4 = 0. The program terminates when the difference between the new solution and the previous one is smaller than 0.00001 within 2000 iterations. Otherwise, it shows Not Found as the final solution.

In JAVA A function foo takes three integers as input arguments, i.e., foo(int a, int b, int c). The three inputs represent the three sides of a triangle in centimeter. The function is expected to return the type of a triangle: "equilateral", "isosceles", or "scalene". Assume the domains of the three variables are 1 ≤ a ≤ 100, 50 ≤ b ≤ 150 and 100 ≤ c ≤ 200, respectively. A test case is in a tuple format <a, b, c, expected_output> with test inputs and the expected output. S1 is a set of test cases for the "Boundary Value Analysis" approach. S1 = S2 is a set of test cases for the "Robustness testing" approach. S2 – S1 = S3 is a set of tests cases for the "Robust Worst-Case testing" approach. Are there any types of triangles that S3 cannot reveal? If yes, what are they? If no, why?

The following is a implementation of the Ackermann function: public static long Ackermann(int m, int n){ 0) return n + 1; if (m == else if (n == return Ackermann(m 1, 1); else return Ackermann(m 1, Ackermann(m, n - 1));

The following recursive method called z is created. This method accepts two parameters: A string s, and an integer index The code in the method is: if (index == s.length()) return ""; <------ base case if(index % 2 == 0) return ""+ s.charAt(index) + z(s,index+1); <---- recursive call else return z(s,index+1); <----- recursive call What would be the output with the call: z("javajavajava",0);

Profile the performance of the memoized version of the Fibonacci function defined in Project 6. The function should count the number of recursive calls. State its computational complexity using big-O notation, and justify your answer. The fib function header has been modified to include the counter as the second parameter. Define the Counter class, it should have three methods: __init__, increment, and __str__. When an instance of the Counter class is passed as a parameter, the count property of that instance should be incremented based on the number of recursive calls. The __str__ method should return the count property's value as a string. ----------------------------------------------------------------------------------- """ File: fib.py Project 11.7 Employs memoization to improve the efficiency of recursive Fibonacci. Counts the calls and displays the results. """ class Counter(object): """Tracks a count.""" # Define the Counter class here. def fib(n, counter = None):...

The factorial of a positive integer n —which we denote as n!—is the product of n and the factorial of n 1. The factorial of 0 is 1. Write two different recursive methods in Java that each return the factorial of n. Analyze your algorithm in Big-Oh notation and provide the appropriate analysis, ensuring that your program has a test class.

I need help problem: A two dimensional random walk simulates the behavior of a particle moving in a grid of points. At each step, the random walker moves north, South, east, or West with probability 1/4, independent of previous moves. Compose a program that takes a command line argument n and estimates how long it will take a random walker to hit the boundary of a 2n-by-2n square centered at the starting point.