Munster Programming Training - Cycle 2

Transcription

1 Munster Programming Training - Cycle 2 Lecture 3 - Binary Search & Queues & Stacks Bastien Pietropaoli bastien.pietropaoli@insight-centre.org

2 Time complexity Previously On MPT Cycle 2 Recursions Exercise - Count words Exercise - Base conversion Questions? 2

3 Time complexity Big-O notation Growth rate Asymptotic (for big numbers) Upper bound (worst case) Best: O(1) Good: O(n) Better: O(log n) Horrible: O(n!) Credit: Wikipedia 3

4 Recursion - General structure In a recursion, you dig until you reach a trivial case. def recursion(data): Doc. if trivial_case1: return value1 elif trivial_case2: return value2... else: return recursion(reduced_data) 4

5 Count words Write a function that counts all the words in a string. def count_words(s): Hint 1: Use the doc! ary/stdtypes.html#string-metho ds import string as str from collections import Counter def count_words(s): """Count all the words present in the string.""" s = s.lower() for c in str.punctuation + str.whitespace: s = s.replace(c, " ") return Counter(s.split()) Hint 2: Get rid of the noise. 5

6 Base conversion (1/2) Write a function that can convert a number from base 10 to any other base. def base_conversion(n, base): Hint 1: Divide. def base_conversion_recursion(n, base, result=""): """Converts number n to the requested base.""" if n == 0: # Trivial case in all bases return "0" result = str(n % base) + result if n // base!= 0: return base_conversion_recursion(n // base, base, result) else: return result Hint 2: Keep the reminder. 6

7 Base conversion (2/2) Write a function that can convert a number from base 10 to any other base. def base_conversion(n, base): Hint 1: Divide. Hint 2: Keep the reminder. def base_conversion(n, base): """Converts number n to the requested base.""" if n == 0: # Trivial case in all bases return "0" # Same principle as the log2 function: digits = [] while n: # True while n > 0 digits.append(n % base) n //= base # Same principle as the list reversion: result = "" for d in digits: result = str(d) + result return result 7

8 Previously - Questions? Any question on last week s material? 8

9 Searching Binary Search Search efficiently! Binary search Interpolation search Complexity 9

10 Searching - Refresher Linear searching def find_something(iter): """Doc""" current_result = default_value for value in iter: if condition: current_result = new_r return current_result def find_something_spec(iter, e): Doc for value in iter: if condition: return result return default_value 10

11 Binary search What if my entries are sorted already? Searching for 7 Binary search: 1) Start in the middle 2) Go one way or the other? 3) Eliminate half of the values. 4) Repeat Credit: Wikipedia 11

12 Interpolation search What if my entries are more or less evenly distributed? Searching for 7 Interpolation search: 1) Interpolate (previously the middle) 2) Eliminate one side. 3) Repeat K = (data - min) / (max - min) interpolation = K * nb_elements 12

13 Complexity Binary search: O(log n) Interpolation search: O(log log n) BUT Interpolation search might actually go to O(n) if the entries are not evenly sorted! Credit: liquidfolders.net 13

14 Practice Exercises Time to get your hands dirty! Binary search The Price is Right 14

15 Binary search Implement a binary search for a large list of integers. 1) Test with range(1000) 2) Test with range( ) 3) Test with range(0, , 2) 4) What if the searched value isn t in the list? 5) Measure the number of operations needed. 6) Measure time of execution. 7) Implement interpolation search. Too big for one slide: go to solution1.py in Exercises/ 15

16 The price is right Make the computer guess your number! 1) Give it a range of values (min, max) 2) Give it the following answers via input(): a) < if your value is lower. b) > if your value is greater. c) = if it found it. Too big for one slide: go to solution2.py in Exercises/ 16

17 Stacks & Queues Simple data structures. Queues Stacks deque 17

18 Queues (1/3) First in, first out (FIFO) You can: Enqueue data Dequeue data Get the size of the queue Credit: Wikipedia 18

19 Queues (2/3) from queue import Queue Using the queue module API: put() to enqueue things get() to dequeue things qsize() to get its size # Create an empty queue: q = Queue() # Enqueue stuff: for i in range(100): q.put(i) q.qsize() # Should be 100 # Dequeue stuff in the same order: for i in range(100): print(q.get()) q.qsize() # Should be 0 Credit: Wikipedia 19

20 Queues (3/3) # Create an empty queue: q = [] Using simple lists API: append() to enqueue things pop(0) to dequeue things len() to get its size # Enqueue stuff: for i in range(100): q.append(i) len(q) # Should be 100 # Dequeue stuff in the same order: for i in range(100): print(q.pop(0)) len(q) # Should be 0 Credit: Wikipedia 20

21 Stacks (1/2) Last in, first out (LIFO) You can: Stack data (push) Unstack data (pop) Get the size of the stack 21

22 Stacks (2/2) # Create an empty stack: s = [] No direct implementation in the STL You can use lists again API: append() to stack things pop() to unstack things len() to get its size # Stack stuff: for i in range(100): s.append(i) len(s) # Should be 100 # Unstack in reverse order: for i in range(100): print(s.pop()) len(s) # Should be 0 22

23 deque to create queues from collections import deque You can use a double-ended queue or deque (pronounced deck ) API: append() to enqueue popleft() to dequeue len() to get its size # Create an empty queue: q = deque() # Enqueue stuff: for i in range(100): q.append(i) len(q) # Should be 100 # Dequeue stuff in the same order: for i in range(100): print(q.popleft()) len(q) # Should be 0 23

24 deque to create stacks from collections import deque You can use a double-ended queue or deque (pronounced deck ) API: append() to enqueue popleft() to dequeue len() to get its size # Create an empty queue: s = deque() # Enqueue stuff: for i in range(100): s.append(i) len(s) # Should be 100 # Dequeue stuff in the same order: for i in range(100): print(s.pop()) len(s) # Should be 0 24

25 Practice Exercises Time to get your hands dirty! Postfix Palindromes 25

26 Postfix Thanks, Milan Postfix expressions are arithmetical expressions where the operators come after anything they operate on. Write a function that evaluates postfix expressions containing only +, -, *, and / def postfix(str): Examples: 3 5 * ---> * > 26 ops = ['-', '+', '*', '/'] def postfix(s): l = [int(e) if e not in ops else e for e in s.split()] # Parse the expression my_stack = [] for e in l: if e not in ops: my_stack.append(e) else: e1, e2 = my_stack.pop(), my_stack.pop() my_stack.append( eval("e1" + e + "e2") ) return my_stack.pop() if name == " main ": s = input("enter your postfix expression: ") print(postfix(s)) 26

27 Palindromes Palindromes are sequences of characters which are read the same backward as forward. Write a function return True if the provided word is a palindrome, False otherwise. def palindrome(str): def palindrome_one_liner(s): return s == s[::-1] def palindrome_stack(s): stack = list(s) for letter in s: if letter!= stack.pop(): return False return True Examples: racecar madam Tacocat whatever ---> True ---> True ---> True ---> False if name == " main ": s = input("enter something to check: ") print(palindrome_one_liner(s)) print(palindrome_stack(s)) 27

28 Discussion & conclusion What we ve seen today: Quick refreshers on complexity and recursions An efficient search algorithm Simple data structures: stacks & queues Where you are in algorithmic: You re getting there slowly. Where you are in Python: It s not really improving, is it? Discussion: Do you think you re getting better? 28

29 Next week: Consolidation Only practice next week! No, I m not too lazy to prepare another lecture, shut up! It actually helps memorisation to work again on the concepts we ve seen before. 29

30 Write functions Bonus material Code and test efficiently. Write tests Use a Unix terminal Fast input 30

31 Write functions Writing functions enable dividing the task into simpler tasks Can I divide my tasks? How much should I divide? Am I solving multiple problems at once? Easier to test: each function can be tested separately. A tiny bit slower. 31

32 Write tests Use test cases (unit tests): Use assert to test your code. Are there cases for which I know the answer? Test non-trivial cases: change boundaries, edge cases, try to break your code to find those cases! Use a lot of cases. Try to go through every line of code 32

33 Use a bash terminal Open a terminal on Linux: Ctrl + Alt + T Kill something: Ctrl + C Get out of something: Ctrl + D Basic bash commands: mkdir my_dir: creates directory my_dir cd my_dir: moves to my_dir pwd: tells you where you are gedit my_file &: edit my_file using gedit. python: gives you the Python shell (like in Idle) python my_script.py: executes your Python script mv my_file new_name: rename my_file to new_name rm my_file: removes my_file 33

34 Fast input My input file: 4 5 * / * My Python script: def whatever(l): l.sort() return l My terminal: user:~$ python my_script.py < my_input_file if name == main : l = [e for e in input().split()] # List comprehension # input() reads one line # split() splits by spaces print(whatever(l)) 34

35 Programming Trivia Rubber Duck Debugging ugging 35