Write the docstring for the following recursive function:
def mystery(a_list): """ Check if list is sorted in ascending order Args: a_list: A list of comparable values Returns: True if listed is sorted in ascending order """ if len(a_list) <= 1: return True else: return (a_list <= a_list) and mystery(a_list[1:])
Try to describe the recursive relationship in a single sentence.
“A list is in sorted order if the first element is less than or equal to the second element and sublist starting with the second element is in sorted order.”
rec_minthat takes a non-empty list as a parameter and returns the minimum value in the list. You must implement this recursively (no loops!) and should not use the
def rec_min(a_list): """ Return the minimum value of a_list using a recursive algorithm """ if len(a_list) == 1: return a_list else: curr = a_list rest = rec_min(a_list[1:]) if rest < curr: return rest else: return curr
Write a function named
rec_in that takes two parameters, a list and an item, and returns True if that item is in the list, and False otherwise. You must implement this recursively (no loops!) and should not use functions like
def rec_in(a_list, item) """ Return True if item is contained in a_list, False otherwise """ if len(a_list) == 0: return False else: if a_list == item: return True else: return rec_in(a_list[1:], item)
A more concise solution (taking advantage of short circuit evaluation of logical expressions):
def rec_in(a_list, item): """ Return True if item is contained in a_list, False otherwise """ if len(a_list) == 0: return False else: return a_list == item or rec_in(a_list[1:], item)
The Fibonacci numbers are the following:
1, 1, 2, 3, 5, 8, 13, 21, ...
The nth Fibonacci number is defined as the sum of the previous two Fibonacci numbers (and the first two numbers are both 1). So, the 3rd Fibonacci number is 2, the 4th Fibonacci number is 3, etc.
Write a function named
fib that takes a number n as a parameter and
returns the nth Fibonacci number. Your function must be a recursive
def fib(n): """ Calculates the nth Fibonacci number recursively """ if (n == 1) or (n == 2): return 1 else: return fib(n-1) + fib(n-2)
fib function above, the call stack would look like
fib(4) fib(3) fib(2) fib(1) fib(2)
and thus the arguments would be 4, 3, 2, 1, 2.
fib function calculates the correct answer, but isn’t
efficient. Try calling your function to calculate the 100th Fibonacci
number. Why is your recursive implementation so slow?
The call stack for
fib(5) fib(4) fib(3) fib(2) fib(1) fib(2) fib(3) fib(2) fib(1)
fib would be called 9 times. The function is slow because it is
performing the same computation over and over again. For example
fib(n-1) also invokes
fib(n-3) (and so on…). We are more than doubling the amount the
computation each time we double n, and in fact the recursive solution has
exponential time complexity.
The program will draw a partial star (6 arms total) with a dot in the center with smaller and smaller arms as they approach the vertical, that is the horizontal line as a total length of 40, the 45 degree arm has a length 20, the vertical arm has a length of 10. Execute the code to see the complete shape.
The code will print:
8 4 2 2 4 2 2