2: Complexity and Recursion

Transcription

1 2: Complexity and Recursion

2 Today About CS1 Complexity Introduction Examples Homework 1 Solutions Project 1 2

3 CS1 Exam Problem 4: Another cipher No problem for most students Highest average score Want detailed comments about your copy? Ask me at the end of the lecture! 3

4 CS1 HWs and Projects Homeworks No big problem Good scores: ~4.8/5 Projects Globally good work Be careful when submitting; sometimes wrong file (or no file) Some students probably copy/paste or receive help from other because solutions are sometimes very similar (including same typo) A few negative comments (next slide) 4

5 CS1 Report How to write a report: Always add a title; anime is not a good title Always add the authors Check that it looks nice Add figures if possible Add explanations, not only copy/paste your code How to submit your python projects Avoid using.rar file use.zip or no compression Submit python 3 file (I received a code for python 2) Submit valid code (no syntax error) and without tabulation (use spaces) 5

6 CS1 Report Typical English problems : Capital letter at the beginning Spaces after punctuation symbols,. : Use spellchecker Plagiarism is forbidden! Ok to cite (short) text and give the reference NOT OK to copy/paste long text especially without origin 6

7 Introduction to Complexity

8 Factorial (last week) For a given problem Multiple solutions (computing factorial) (one recursive and two iterative) Which one is the best? Can we compare them? # Two iterative solutions def fact_iter_for(n): res = 1 for k in range(1, n+1): res *= k return res # A recursive solution def fact_rec(n): if n == 0: return 1 else: return n * fact_rec(n-1) def fact_iter_while(n): res = 1 k = n while k > 1: res *= k k -= 1 return res 8

9 (Computational) Complexity From Wikipedia: The complexity of an algorithm is the amount of resources required for running it. In computer science, two resources: Time: How long time does it take to execute? Space: How much memory does it use? 9

10 Complexity Time complexity: Not based on real time Number of (basic) Space complexity: Number of elements stored in memory operations: - number of add/multi. - number of tests - number of recursive calls - 10

11 Complexity Examples # Two iterative solutions def fact_iter_for(n): res = 1 for k in range(1, n+1): res *= k return res fact_iter_for k goes from 1 to n n iterations 1 multiplication per iteration fact_iter_while k goes from n to 1 n iterations 1 multi + 1 sub + 1 test per iteration def fact_iter_while(n): res = 1 k = n while k > 1: res *= k k -= 1 return res 3 variables (n, res, k) In both cases: Constant amount of memory (independent of the input n) 3 integer variables Linear time complexity (total number of operations = n iterations * constant nb of op per iteration) 11

12 Complexity Examples # A recursive solution def fact_rec(n): if n == 0: return 1 else: return n * fact_rec(n-1) fact(5) = 5 * fact(4) fact_rec More difficult to measure Let's count the number of calls To compute fact(n) n+1 calls to fact Linear time complexity again (Less clear for memory usage) fact(4) = 4 * fact(3) fact(3) = 3 * fact(2) fact(2) = 2 * fact(1) fact(1) = 1 * fact(0) fact(0) = 1 12

13 Homework 1

14 Fibonacci Recursive # Recursive solution to compute Fibonacci numbers def fibo_rec(n): if n == 0 or n == 1: return 1 else: return fibo_rec(n-1) + fibo_rec(n-2) What is the time complexity? Not good Exponential with respect to the input n 14

15 Fibonacci Iterative 1 # Iterative solution to compute Fibonacci numbers def fibo_iter(n): values = [0]*(n+1) values[0] = 1 # Create an array of (n+1) zeros # Initialization with known values[1] = 1 # values for n=0 and n=1 for k in range(2, n+1): # Compute successive Fibo numbers values[k] = values[k-1] + values[k-2] return values[n] What is the time complexity? Seems much better than previous one Easy to evaluate: loop of size ~n linear complexity Execution time should grow proportionally with n (not exactly correct since values also becomes larger and operations may take longer time) 15

16 Fibonacci Iterative 2 # Iterative solution to compute Fibonacci numbers # defiterative fibo_iter_mem(n): solution to compute Fibonacci numbers def fibo_iter(n): if n == 0 or n == 1: return 1 # Not needed, but clearer values penultimate = [0]*(n+1) = 1 values[0] last = 1 = 1 # Create an array of (n+1) zeros # Initialization with known values[1] for k in range(2, = 1 n+1): # values for n=0 and n=1 Best iterative for k next in = range(2, penultimate n+1): + last # Compute successive Fibo numbers values[k] penultimate = values[k-1] = last + values[k-2] return last values[n] = next solution return last What is the space complexity (memory usage)? To compute fibo_iter(n), we use an array of size n (+1 is negligible) Can we do better? Yes, for each iteration, we need only the last two values fibo_iter_mem uses only 5 variables Constant space compl. 16

17 Project 1

18 Project 1 Tower of Hanoi Context 3 pegs, n discs, 1 tower Move rules (disk) one at a time only top of tower always on larger disc source: Wikipedia peg Goal move tower to other peg disc Goal tower 18

19 Project 1 Tower of Hanoi Example n = 2 peg 0 peg 2 disk 0 disk 1 move disk 0 from peg 0 to peg 2 move disk 1 from peg 0 to peg 1 move disk 0 from peg 2 to peg 1 Goal! 19

20 Project Guidance What to do: Understand the file hanoi.py Complete the (recursive) function move_tower( ) Write a report (2-3 pages) explaining: 15pts - what you did, - how you did it, - why it works, - + some bonus points for great solutions, and/or nice reports 5pts Add something personal to your project (iterative solution, nicer display of the pegs, another similar game, ) Deadline: Probably December 24~28 (in ~2weeks). 20

21 Bonus Questions Write a recursive solution of Fibonacci with linear time complexity without using memorization techniques check for tail recursive notion How to count the number of calls in a recursive function in Python? 21