1. 1 Programming for Engineers in Python Autumn 2011-12 Lecture 8: Recursion

2. 2 Lecture 7: Highlights

3. 3 Lecture 6 (OOP): Highlights Representation design options and implications (Rectangle) Inheritance and Polymorphism Rational - customize classes so that they are natural to use Attributes, methods, constructor Method overriding (e.g., __str__) Operators overloading (e.g., __add__)

4. 4 Variables in Functions Defined only in the function’s scope Are not available for other functions/shell (even function’s parameters) Upon completion of execution: Variables are not defined anymore Variables values are not kept for future invocations of the function

5. 5 The Call Stack call stack result main base exponent res i power = 2 = 20 = 3 = 15 = 5 = 17

6. 6 Towers of Hanoi Objective: Move the entire stack of disks from rode S (source) to T (target) using A (auxiliary) STA

7. 7 The Rules Only one disk may be moved at a time Each move consists of taking the upper disk from one of the rods and sliding it onto another rod No disk may be placed on top of a smaller disk STA

8. 8 Examples STA 1 disk – very easy! STA 2 disks – very easy! STA 3 disks – easy STA 4 disks?

9. 9 Solution for 4 Disks STASTASTASTA

10. 10 For n Disks? STA

11. 11 Assume We Have a Solution for n-1 Disks STA

12. 12 Solution: Step 1 STA

13. 13 Solution: Step 2 STA

14. 14 Solution: Step 3 STA

15. 15 How to Solve for n-1 Disks? Easy!

16. 16 Algorithm for n Disks STA 1. If there is only a single disk – easy! 2. Move n-1 disks from S to A (T is the auxiliary rode) 3. Move disk from S to T 4. Move n-1 disks from A to T (S is the auxiliary rode) Let us write it in Python…

17. 17 A Python Program for Towers of Hanoi

18. 18 Remember the Calling Stack? hanoi(3,'S','T','A') main hanoi(2,'S',‘A',‘T')hanoi(1,‘S',‘T',‘A') And so on…

19. 19 Recursion We use Recursion to solve the Towers of Hanoi problem Recursion: a function whose implementation references itself Recursion enables to solve a “large” problem using solutions to “small” problems that assemble it In every recursive call the problem is reduced. When the problem is small enough -solve directly (base case, מקרה קצה) Divide and conquer

20. 20 Iterative Versus Recursive Step by step (iteratively): 4! = 1*2*3*4 = 2*3*4 = 6*4 = 24 2 4 = 2*2*2*2 = 4*2*2 = 8*2 = 16 n! = 1*2*3*….*n a n = a*a*…..*a n iterations n! = n*(n-1)! 0! = 1 Recursively: 4! = 4*3! = 4*(3*2!) = 4*(3*(2*1!)) = 4*(3*(2*(1*0!))) = 4*(3*(2*(1*1))) = 4*(3*(2*1)) = 4*(3*2) = 4*6 = 24

21. 21 Recursive Definition n! = n*(n-1)! 0! = 1 Base condition מקרה קצה Recursive call Smaller instance Factorial

22. 22 Pros and Cons Pros: s hort and natural for many problems Cons: Computational inefficient, sometimes hard to understand or inconvenient

23. 23 Recursion Example in Python Halting condition (and infinite loops) Advance towards base case

24. 24 Recursive factorial – step by step factorial(4) n 4 Returns…

25. 25 Recursive factorial – step by step factorial(4) n 4 Returns… 4*…

26. 26 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns…

27. 27 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns…

28. 28 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… 3*…

29. 29 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns…

30. 30 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns…

31. 31 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… 2*…

32. 32 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns…

33. 33 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns…

34. 34 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… 1*…

35. 35 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… factorial(0) n 0 Returns…

36. 36 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… factorial(0) n 0 Returns…

37. 37 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… factorial(0) n 0 Returns…

38. 38 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… factorial(0) n 0 Returns… 1

39. 39 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… factorial(1) n 1 Returns… 1*1

40. 40 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… factorial(2) n 2 Returns… 2*1

41. 41 Recursive factorial – step by step factorial(4) n 4 Returns… factorial(3) n 3 Returns… 3*2

42. 42 Recursive factorial – step by step factorial(4) n 4 Returns… 4*6

43. 43 General Form of Recursive Algorithms Base case: small (non-decomposable) problem Recursive case: larger (decomposable) problem At least one base case, and at least one recursive case. test + base case recursive case

44. 44 Short Summary Design a recursive algorithm by 1. Solving big instances using the solution to smaller instances 2. Solving directly the base cases Recursive algorithms have 1. Stopping criteria 2. Recursive case(s) 3. Construction of a solution using solution to smaller instances

45. 45 Point for Attention: Memory Variables of a called function are kept in memory until the function returns Many recursive calls might fill the computers memory Even if we minimize the number of variables, recursion has its price

46. 46 Example: Fibonacci Series Fibonacci series 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 Definition: fib(0) = 0 fib(1) = 1 fib(n) = fib(n-1) + fib(n-2) en.wikipedia.org/wiki/Fibonacci_number

47. 47 סלט פיבונאצ'י

48. 48 Recursive Fibonacci Series Every call with n > 1 invokes 2 function calls, and so on…

49. 49 Redundant Calls Fib(4) Fib(3)Fib(2) Fib(1) Fib(0) Fib(1) Fib(0) Fib(5) Fib(3) Fib(2)Fib(1) Fib(0)

50. 50 Number of Calls to Fibonacci nvalueNumber of calls 111 213 325 232865792735 2446368150049

51. 51 Demonstration: Iterative Versus Recursive Fibonacci

52. 52 Demonstration: Iterative Versus Recursive Fibonacci Output (shell):

53. 53 Fibonacci: Recursion and Efficiency If a recursive function calls itself more than once it will be extremely inefficient Define it iteratively

54. 54 So Do We Really Need Recursion? Yes! (specific examples next week)

55. 55 Odd-Even (if time allows) Given a function ‘odd(n)’ Odd n - return True, Even n – return False Write a function ‘even(n)’ that: Even n - return True, Odd n – return False This is easy!

56. 56 Odd-Even

57. 57 Odd-Even

58. 58 Odd-Even

59. 59 Odd-Even

60. Questions?

61. 61 Off Topics Documenting your programs Find the error

62. 62 Documenting Your Programs An essential part of writing computer code Understand what was your intension when writing it For others to be able to coordinate their code with yours For the grader/lecturer to try and understand your code and grade it accordingly…

63. 63 Documenting Your Programs with Comments Comments: pieces of code not interpreted or executed by the computer One line comments start with the hash character (#)

64. 64 Meaningful Variables Names Variables names Meaningful names

65. Off Topic: Find the Error

66. And Now?

68. INDENTATION IS REALLY, REALLY IMPORTANT!