Solutions

Author: OmarAlmighty

CH15/Checkpoints

@@ -0,0 +1,105 @@
+#15.1
+A recursive function is one that invokes itself.
+
+#15.2
+6 times.
+
+#15.3
+f(n) = 2 if n = 1
+f(n) = 2 * f(n-1) if (n > 1)
+
+#15.4
+f(x, n) = x if n = 1
+f(x, n) = x * f(n-1) if (n > 1)
+
+#15.5
+f(n) = 1 if n=1
+f(n) = n + f(n-1) if n>1
+
+#15.6
+Infinite recursion: if recursion does not reduce the problem in a manner that
+allows it to eventually converge into the base case
+Direct recursion: a recursion where the recursive function only invokes itself.
+Indirect recursion: a recursion where tow or more functions invoke each other in a recursive manner.
+This occurs when function A invokes function B, which in turn invokes function A.
+
+#15.7
+25 times:
+number of time fib is invoked in fib(6) =
+1+ number of time fib is invoked in fib(4)+number of time fib is invoked in fib(5) = 1+9+15=25
+
+#15.8
+(a)
+Output: 15 (5 + 4 + 3 + 2 + 1 = 15)
+Base case: if (n == 1)
+Recursive call: f(n – 1)
+(b)
+Output: 7654321
+Base case: if (n > 0)
+Recursive call: f(n // 10)
+
+#15.9
+1) The function is implemented using an if-else or a switch statement that leads to
+different cases.
+2) One or more base cases (the simplest case) are used to stop recursion.
+3) Every recursive call reduces the original problem, bringing it increasingly closer to a
+base case until it becomes that case.
+
+#15.10
+SKIPPED.
+
+#15.11
+(a) 5 4 3 2 1
+(b) 1 2 3 4 5
+
+#15.12
+n/10 should be n//10
+
+#15.13
+A second function that receives additional parameters used with the original recursive function.
+
+#15.14
+SKIPPED.
+
+#15.15
+■ os.path.isfile(s), which returns True if s is a filename. Recall that this function
+  was introduced in §13.2.3 to check if a file exists.
+■ os.path.getsize(filename), which returns the size of the file.
+■ os.listdir(directory), which returns a list of the subdirectories and files
+  under the directory.
+
+#15.16
+31 times.
+
+#15.17
+Any recursive functions can be converted into a non-recursive function.  (TRUE)
+Recursive function usually takes more time and memory to execute than non-recursive functions. (TRUE)
+Recursive functions are always simpler than non-recursive functions. (FALSE)
+There is always a condition statement in a recursive function to check whether a base case is reached. (TRUE)
+
+#15.18
+When a function is invoked, its contents are placed into a stack. If a function is recursively invoked,
+it is possible that the stack space is exhausted. This causes stack overflow.
+
+#15.19
+A recursive function is said to be tail recursive if there are no pending operations to be performed
+on return from a recursive call.
+
+#15.20
+Tail recursion may be desirable: Because the function ends when the last recursive call
+ends, there is no need to store the intermediate calls in the stack.
+
+#15.21
+Yes.
+
+#15.22
+# Return the Fibonacci number for the specified index
+def fib(index):
+    return fib1(index, 1, 0)
+
+# Auxiliary tail-recursive function for fib
+def fib1(index, next, result):
+    if (index == 0):
+        return result
+    else:
+        return fib1(index - 1, next + result, next)

CH15/EX15.01.py

@@ -0,0 +1,17 @@
+# 15.1 (Sum the digits in an integer using recursion) Write a recursive function that computes
+# the sum of the digits in an integer. Use the following function header:
+# def sumDigits(n):
+# For example, sumDigits(234) returns Write a test program
+# that prompts the user to enter an integer and displays its sum.
+
+
+def sumDigits(n):
+    if n == 0:
+        return n
+
+    return (n % 10 + sumDigits(n//10))
+
+
+n = eval(input("Enter a digit: "))
+
+print("The sum of the digits is:", sumDigits(n))

CH15/EX15.02.py

@@ -0,0 +1,26 @@
+# 15.2 (Fibonacci numbers) Rewrite the fib function in Listing 15.2 using iterations.
+# (Hint: To compute fib(n) without recursion, you need to obtain fib(n - 2)
+# and fib(n - 1) first.) Let f0 and f1 denote the two previous Fibonacci numbers.
+# The current Fibonacci number would then be f0 + f1. The algorithm can be
+# described as follows:
+# f0 = 0 # For fibs(0)
+# f1 = 1 # For fib(1)
+# for i in range(2, n + 1):
+# currentFib = f0 + f1
+# f0 = f1
+# f1 = currentFib
+# # After the loop, currentFib is fib(n)
+# Write a test program that prompts the user to enter an index and displays its
+# Fibonacci number.
+
+n = eval(input("Enter a number: "))
+
+f0 = 0
+f1 = 1
+fib = 0
+for i in range(2, n + 1):
+    fib = f0 + f1
+    f0 = f1
+    f1 = fib
+
+print("The Fibonacci of", n, "is", fib)

CH15/EX15.03.py

@@ -0,0 +1,16 @@
+# 15.3 (Compute greatest common divisor using recursion) The gcd(m, n) can also be
+# defined recursively as follows:
+# ■ If m % n is 0, gcd(m, n) is n.
+# ■ Otherwise, gcd(m, n) is gcd(n, m % n).
+# Write a recursive function to find the GCD. Write a test program that prompts the
+# user to enter two integers and displays their GCD.
+
+def gcd(m, n):
+    if m % n == 0:
+        return n
+    return gcd(n, m % n)
+
+
+m, n = eval(input("Enter two numbers: "))
+
+print("The GCD of", m, "and", n, "is", gcd(m, n))

CH15/EX15.04.py

@@ -0,0 +1,12 @@
+# 15.4 (Sum series) Write a recursive function to compute the following series:
+# m(i) = 1 + 1/2 + 1/3 + ... + 1/i
+# Write a test program that displays m(i) for i 1, 2, ..., 10.
+
+def sumSeries(i):
+    if i == 1:
+        return 1
+    return 1 / i + sumSeries(i-1)
+
+
+for i in range(1, 11):
+    print("The sum series for i=", i, "is", sumSeries(i))

CH15/EX15.05.py

@@ -0,0 +1,11 @@
+# 15.5 (Sum series) Write a recursive function to compute the following series:
+# m(i) = 1/3 + 2/5 + 3/7 + 4/9 + 5/11 + 6/13 + ... + i/2i + 1
+# Write a test program that displays m(i) for i 1, 2, ..., 10.
+
+def sumSeries(i):
+    if i == 1:
+        return 1/3
+    return i / (2 * i + 1) + sumSeries(i - 1)
+
+for i in range(1, 11):
+    print("The sum series for i=", i, "is", sumSeries(i))

CH15/EX15.06.py

@@ -0,0 +1,12 @@
+# 15.6 (Summing series) Write a recursive function to compute the following series:
+# m(i) = 1/2 + 2/3 + ... + i/i + 1
+# Write a test program that prompts the user to enter an integer for i and displays m(i).
+
+def sumSeries(i):
+    if i == 1:
+        return 1 / 2
+    return i / (i + 1) + sumSeries(i - 1)
+
+
+for i in range(1, 11):
+    print("The sum series for i=", i, "is", sumSeries(i))

CH15/EX15.07.py

@@ -0,0 +1,21 @@
+# 15.7 (Fibonacci series) Modify Listing 15.2 so that the program finds the number of
+# times the fib function is called. (Hint: Use a global variable and increment it
+# every time the function is called.)
+
+counter = 0
+
+
+def fib(index):
+    global counter
+    counter += 1
+    if index == 0:  # Base case
+        return 0
+    elif index == 1:  # Base case
+        return 1
+    else:  # Reduction and recursive calls
+        return fib(index - 1) + fib(index - 2)
+
+
+index = eval(input("Enter an index for a Fibonacci number: "))
+fib(index)
+print("The Fibonacci function is called", counter, "times")

CH15/EX15.08.py

@@ -0,0 +1,15 @@
+# 15.8 (Print the digits in an integer reversely) Write a recursive function that displays
+# an integer value reversely on the console using the following header:
+# def reverseDisplay(value):
+# For example, invoking reverseDisplay(12345) displays 54321. Write a test
+# program that prompts the user to enter an integer and displays its reversal.
+
+def reverseDisplay(value):
+    if value == 0:
+        print()
+    else:
+        print(value % 10, end='')
+        reverseDisplay(value // 10)
+
+val = eval(input("Enter an integer: "))
+reverseDisplay(val)

CH15/EX15.09.py

@@ -0,0 +1,16 @@
+# 15.9 (Print the characters in a string reversely) Write a recursive function that displays
+# a string reversely on the console using the following header:
+# def reverseDisplay(value):
+# For example, reverseDisplay("abcd") displays dcba. Write a test program
+# that prompts the user to enter a string and displays its reversal.
+
+def reverseDisplay(value):
+    if value == '':
+        print()
+    else:
+        print(value[-1], end='')
+        reverseDisplay(value[:len(value) - 1])
+
+
+val = input("Enter a string: ")
+reverseDisplay(val)