Recursion

Can a recursive function be reimplemented by means of iteration? If yes, how? Give an example.

Yes, we need to use a loop and store past results in either accumulators or a stack. Example: Recursion: def factorial_recursive(n): if n == 0: return 1 else: return n * factorial(n - 1) Iteration: def factorial_iterative(n): result = 1 for i in range(1, n + 1): result *= i return result

Briefly describe the concept of tail recursion by 1. Providing an example and explaining how it works; 2. Describing how tail recursion works and how it differs from regular recursion.

- Tail recursion calculates the result on the way down into the call of the functions - Tail recursion is a special form of recursion in which the recursive call is the last operation performed by the function. 1. Example: def factorial_tail_recursive(n, result=1): if n == 0: return result else: return factorial_tail_recursive(n - 1, n * result) In tail recursion, like the factorial example, the recursive call is the last operation in the function, and intermediate results are passed as arguments, allowing for efficient calculation without stacking multiple function call frames. 2. - In tail recursion, each recursive call can be optimised by replacing it with a jump to the beginning of the function, eliminating the need for a new stack frame. - Regular recursion creates a new stack frame for each recursive call, which can lead to stack overflow errors and decreased performance.

Analyze the python code provided below and determine whether it is tail recursive or not. Explain your reasoning. Finally, if the provided function is not tail recursive, explain how it could be modified to use tail recursion. If tail recursive, explain what makes it tail recursive. def mystery(a, b): r = a % b if r == 0: return b return mystery(a, r) + mystery(b, r)

- The mystery function is NOT tail recursive. It solves the problem "on the way back" when it performs additional operations after the recursive calls in line 5 - Addition of the 2 recursive calls - In tail recursion, the recursive call is the last operation performed by the function, and the result of the recursive call is immediately returned without any additional computation. - To make it tail recursive, use an accumulator to keep track of the result and pass it into the recursive call - Can introduce an auxiliary function - In a modified version, the recursive call tail_recursive_mystery(b, r, accumulator + b) is the last operation before returning a result, making it tail recursive.

Consider the following example Python function: def mystery(arr): if len(arr) == 0: return 0 elif len(arr) == 1: return arr[0] else: mid = len(arr) // 2 return mystery(arr[:mid]) + mystery(arr[mid:]) 1 Explain what is the purpose of this function. 2. What is the base case for this function? 3. Is it tail-recursive? 4. What is the output of this function for arr = [1, 2, 3, 4, 5, 6, 7, 8] 5. How does the function recurse and how does the return value change in each call? 6. Write an equivalent iterative version of this function. 7. What is the best- and worst-case time complexity of the recursive function? Give a one-line scenario for each complexity with the variables defined.

1. Purpose of the Function: The purpose of this function, mystery(arr), is to recursively calculate the sum of all elements in the input list arr. 2. Base Case: The base cases for this function are: if len(arr) == 0: Returns 0 when the input list is empty. elif len(arr) == 1: Returns the only element in the list when it contains only one element. 3. Tail-Recursiveness: No, the function is not tail-recursive because the recursive calls are followed by addition operations (mystery(arr[:mid]) + mystery(arr[mid:])) before returning the result. 4. 36 5. The function starts by splitting the input list arr into two halves (arr[:mid] and arr[mid:]) and recursively calculates the sum of each half. These sums are then added together to compute the final result. The recursion continues until the base cases are reached, where it either returns 0 for an empty list or the single element for a list with one element. 6. Equivalent Iterative Version: def iterative_mystery(arr): total = 0 for item in arr: total += item return total 7. Time Complexity: Best/Worst-case complexity: O(n) where n is the size of the input list - the function needs to iterate through all of them and sum them up, leading to a linear time complexity. (not taking small input size and empty list into account eg. when it is [] or list with one element)

Consider the following example Python function: def mystery(arr): if len(arr) == 0: return 0 else: return arr[0] + mystery(arr[2:]) 1 Explain what is the purpose of this function. 2. What is the base case for this function? 3. Is it tail-recursive? 4. What is the output of this function for arr = [1, 2, 3, 4, 5, 6, 7, 8] 5. How does the function recurse and how does the return value change in each call? 6. Write an equivalent iterative version of this function. 7. What is the best- and worst-case time complexity of the recursive function? Give a one-line scenario for each complexity with the variables defined.

1. Purpose of the Function: The purpose of this function, mystery(arr), is to recursively sum the elements of a list arr while skipping every second element (starting from the first element). 2. Base Case: The base case for this function is when arr is an empty list (len(arr) == 0). In this case, the function returns 0. 3. Tail-Recursiveness: No, the function is not tail-recursive because the recursive call mystery(arr[2:]) is followed by an addition operation (arr[0] + ...) before returning the result. 4. 16 5. The function starts with the first element of the input list arr[0] and adds it to the result of the recursive call mystery(arr[2:]). With each recursive call, it skips every second element of the list. The return value accumulates the sum as it progresses through the list. 6. Equivalent Iterative Version: def iterative_mystery(arr): total = 0 i = 0 while i < len(arr): total += arr[i] i += 2 return total 7. Time Complexity: Best/Worst-case complexity: O(n) where n is the size of the input list - the function needs to traverse all elements while skipping every second one, leading to a linear time complexity. (not taking small input size and empty list into account eg. when it is [] or list with one element)

Consider the following example Python function: def mystery(n): if n <= 1: return n else: return mystery(n - 1) + mystery(n - 2) 1 Explain what is the purpose of this function. 2. What is the base case for this function? 3. Is it tail-recursive? 4. What is the output of this function for n = 3 5. How does the function recurse and how does the return value change in each call? 6. Write an equivalent iterative version of this function. 7. What is the best- and worst-case time complexity of the recursive function? Give a one-line scenario for each complexity with the variables defined.

1. Purpose of the Function: The purpose of this function, mystery(n), is to compute the nth term of the Fibonacci sequence recursively. 2.Base Case: The base cases for this function are defined as: if n <= 1: Returns n when n is less than or equal to 1. These base cases handle the starting values of the Fibonacci sequence (F(0) = 0 and F(1) = 1). 3. Tail-Recursiveness: No, the function is not tail-recursive because the recursive calls mystery(n - 1) and mystery(n - 2) are followed by addition operations before returning the result. 4. 3 5. The function computes the Fibonacci sequence by recursively adding the (n-1)th and (n-2)nd terms. It continues to make these recursive calls until it reaches the base cases, where it returns the values of n when n is less than or equal to 1. 6. Equivalent Iterative Version: def iterative_mystery(n): if n <= 1: return n a, b = 0, 1 for _ in range(2, n + 1): a, b = b, a + b return b 7. Time Complexity: Best/Worst-case complexity: O(2^n) where n is the size of the input list - the function recursively branches into two calls for each level of recursion and each level has constant-time operations, resulting in an exponential growth of function calls (not taking small input size and empty list into account eg. when it is [] or list with one element)

Briefly describe the concept of recursion in Computer Science by 1. Providing a definition of recursion in your own words; 2. Providing an example and explaining how it works; 3. Explaining what is the base case and recursive case of the example given.

1. Recursion is an algorithm that solves a large problem by reducing it to one or more sub-problems that are of the same kind as the original and simpler to solve. 2. & 3. Example of recursion: def factorial(n: int) -> int: if n == 0: return 1 else: return n*factorial(n-1) This recursive function would work by first checking for the base case of this problem, which is the final sub-problem that can be used to return to and solve the original problem (the if block). If the input n is the number 0, which guarantees it to be the base case, as 0! will return 1, the recursive program would be able to immediately solve the problem. However, if n was a number bigger than 0, then the function would have to repeatedly make recursive calls (the else block) to solve each number by using n - 1 as its argument. This is where the recursive calls break the original problem down into smaller problems and will continue to make recursive calls until n = 0. From there the function will then solve all the smaller subproblems and then combine them together to create the final solution.

1. Contrast the operation of recursion and iteration in Computer Science. 2. Analyze the advantages and disadvantages of using recursion over iteration in Computer Science. 3. Provide an example and explain the reasoning behind your answers.

1. Recursion solves a large problem by reducing it to one or more sub-problems that are of the same kind as the original and simpler to solve. It uses function calls that invoke themselves with modified input until a base case is reached. On the other hand, iteration involves solving a problem through loops and repetitive execution of code. It uses loops like 'for' or 'while' to repeatedly perform a set of instructions. 2. & 3. Advantages of using recursion compared to iteration: - Provides a clear and intuitive way to solve problems that have a recursive structure. - Simplifies code and reduces redundancy when solving problems that naturally decompose into smaller subproblems. Example: def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) Reasoning: Recursion simplifies the problem by expressing it in terms of smaller subproblems (factorial of n - 1). It's intuitive for problems that naturally decompose into smaller instances. Disadvantages of using recursion compared to iteration: As recursive calls push a new frame onto the call stack, if the input number n in a recursive function has a large size, it is possible for the stack to reach a number that's too large which may cause stack overflow, which could make the program crash. Example: Recursion: def factorial_recursive(n): if n == 0: return 1 else: return n * factorial(n - 1) result = factorial_recursive(1000) print(result) Iteration: def factorial_iterative(n): result = 1 for i in range(1, n + 1): result *= i return result result= factorial_iterative(1000) print(result) Reasoning: When attempting to calculate the factorial of 1000, recursion often results in a "RecursionError: maximum recursion depth exceeded" due to stack overflow. In contrast, iteration efficiently computes the factorial without memory issues or errors. This highlights recursion's potential memory inefficiency in deep calls as each function call consumes stack space, while iteration manages memory efficiently.

Define the concepts of recursion and iteration and explain how they differ in terms of their properties: 1. Provide at least one advantage and disadvantage of using recursion compared to iteration, 2. Provide examples to support your points.

1. Recursion solves a large problem by reducing it to one or more sub-problems that are of the same kind as the original and simpler to solve. It uses function calls that invoke themselves with modified input until a base case is reached. On the other hand, iteration involves solving a problem through loops and repetitive execution of code. It uses loops like 'for' or 'while' to repeatedly perform a set of instructions. 2. & 3. Advantages of using recursion compared to iteration: - Provides a clear and intuitive way to solve problems that have a recursive structure. - Simplifies code and reduces redundancy when solving problems that naturally decompose into smaller subproblems. Example: def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) Reasoning: Recursion simplifies the problem by expressing it in terms of smaller subproblems (factorial of n - 1). It's intuitive for problems that naturally decompose into smaller instances. Disadvantages of using recursion compared to iteration: As recursive calls push a new frame onto the call stack, if the input number n in a recursive function has a large size, it is possible for the stack to reach a number that's too large which may cause stack overflow, which could make the program crash. Example: Recursion: def factorial_recursive(n): if n == 0: return 1 else: return n * factorial(n - 1) result = factorial_recursive(1000) print(result) Iteration: def factorial_iterative(n): result = 1 for i in range(1, n + 1): result *= i return result result= factorial_iterative(1000) print(result) Reasoning: When attempting to calculate the factorial of 1000, recursion often results in a "RecursionError: maximum recursion depth exceeded" due to stack overflow. In contrast, iteration efficiently computes the factorial without memory issues or errors. This highlights recursion's potential memory inefficiency in deep calls as each function call consumes stack space, while iteration manages memory efficiently.

Can an iterative function be reimplemented by means of recursion? If yes, how? Give an example.

Yes, iterations are replaced by function calls and the base case becomes the (negated) condition of the loop. It often needs an auxiliary function to prepare the converging arguments. Example: Iteration: def factorial_iterative(n): result = 1 for i in range(1, n + 1): result *= i return result Recursion: def factorial_recursive(n): if n == 0: return 1 else: return n * factorial(n - 1)