Announcements: Project 5

1. Announcements: Project 5 • Everything we have been learning thus far will enable us to solve interesting problems • Project 5 will focus on applying the skills we have learned on a problem from biology, specifically computational biology • Email your group / group requests by Friday • Project 5 will be released tomorrow late afternoon

2. Announcements • Midterm 2: Same curve as Midterm 1 • Pre Lab 15 will be released next Friday • Stale version of week 12 slides was accidently uploaded to the wiki (correct slides were presented in class) – this has been fixed, please re download

3. O(1) Example >>> isOdd([0]) True >>> isOdd([0,1]) False defisOdd(list): return (len(list)%2 == 1)

4. Clicker Question defgetFirst(list): iflen(list) == 0: return -1 return (list[0]) >>> getFirst([]) -1 >>> getFirst([0,1,2,3]) 0 >>> getFirst(["a", "b", "c"]) 'a’ A: O(n) B: O(n2) C: O(1)

5. Building the Intuition • Logic Puzzle: • You have 9 marbles. 8 marbles weigh 1 ounce each, & one marble weighs 1.5 ounces. You are unable to determine which is the heavier marble by looking at them. How do you find the marble which weighs more?

6. Solution 1: Weigh one marble vs another • What is the complexity of this solution?

7. Finding the complexity • Step 1: What is our input? • The marbles • Step 2: How much work do we do per marble? • We weight each marble once (except one) • Step 3: What is the total work we did? • 8 measurements • What if we had 100 marbles or 1000?

8. Clicker Question: What is the complexity of this algorithm? A: O(n) B: O(n2) C: O(1) D: O(log n)

9. We can do better! • Lets pull some intuition from our search algorithm that was O(log n) • We want a way to eliminated ½ (or more) of the marbles with each measurement • How might we do this? • What about weighing multiple marbles at once?

10. The Optimal Solution • Split the marbles into three groups • We can then weigh two of the groups

11. Finding the complexity of the optimal solution • Step 1: What is our input? • The marbles • Step 2: How much work do we do per marble? • Logarithmic • Step 3: What is the total work we did? • 2 measurements • What if we had 100 marbles or 1000?

12. What happens at each step? • We eliminated 2/3rds of the marbles

13. Clicker Question: What is the complexity of this algorithm? A: O(n) B: O(n2) C: O(1) D: O(log n)

14. Sorting • Motivation • We can answer questions like min/max very efficiently • We can search very efficiently • What if we need to search many many times • Many algorithms require their input to be sorted

15. Intuition behind bubble sort • Background reading (homework): http://en.wikipedia.org/wiki/Bubble_sort • Bubble sort takes a list and returns a sorted list • Compare each pair of adjacent items and swap them if the one to the right is smaller • Assumption: we want our list sorted from smallest to greatest

16. Intuition behind bubble sort [5, 7, 9, 0, 3, 5, 6] [5, 7, 9, 0, 3, 5, 6] [5, 7, 9, 0, 3, 5, 6] [5, 7, 9, 0, 3, 5, 6] [5, 7, 0, 9, 3, 5, 6] [5, 7, 0, 3, 9, 5, 6] [5, 7, 0, 3, 5, 9, 6] [5, 7, 0, 3, 5, 6, 9]

17. Intuition behind bubble sort [5, 7, 0, 3, 5, 6, 9] [5, 7, 0, 3, 5, 6, 9] [5, 7, 0, 3, 5, 6, 9] [5, 0, 7, 3, 5, 6, 9] [5, 0, 3, 7, 5, 6, 9] [5, 0, 3, 5, 7, 6, 9] [5, 0, 3, 5, 6, 7, 9] [5, 0, 3, 5, 6, 7, 9]

18. Intuition behind bubble sort • How many passes do we have to do before we are guaranteed the list is sorted? • n passes, where n is the length of the list • In each pass we do how much work? • n-1 comparisons • What is the total work? Complexity?

19. Changing our Intuition into Code defBubbleSort(myList): swapped = True while swapped: swapped = False for i in range(len(myList)-1): if myList[i] > myList[i+1]: temp = myList[i] myList[i] = myList[i+1] myList[i+1] = temp swapped = True return myList The main loop Keep executing the loop IF we do a swap

20. Changing our Intuition into Code defBubbleSort(myList): swapped = True while swapped: swapped = False for i in range(len(myList)-1): if myList[i] > myList[i+1]: temp = myList[i] myList[i] = myList[i+1] myList[i+1] = temp swapped = True return myList The loop that executes the swaps

21. Changing our Intuition into Code defBubbleSort(myList): swapped = True while swapped: swapped = False for i in range(len(myList)-1): if myList[i] > myList[i+1]: temp = myList[i] myList[i] = myList[i+1] myList[i+1] = temp swapped = True return myList Check if the two numbers should be swapped

22. Changing our Intuition into Code defBubbleSort(myList): swapped = True while swapped: swapped = False for i in range(len(myList)-1): if myList[i] > myList[i+1]: temp = myList[i] myList[i] = myList[i+1] myList[i+1] = temp swapped = True return myList Swap!

23. Fast Swapping of Two Variables • Python provides us the ability to perform the swap in a much more efficient manner variable1, variable 2 = variable2, variable1 >>> a = 5 >>> b = 7 >>> a, b = b, a >>> print a 7 >>> print b 5

24. Changing our Intuition into Code defBubbleSort(myList): swapped = True while swapped: swapped = False for i in range(len(myList)-1): if myList[i] > myList[i+1]: myList[i], myList[i+1] = myList[i+1], myList[i] swapped = True return myList Swap!

25. Homework • Reach Chapter 11 from the text book

26. Can we sort faster? • Bubble sort certainly will sort our data for us • Unfortunately it simply is not fast enough • We can sort faster! • There are algorithms which sort in O(n log n) or log linear time • Lets reason why this is the case

27. Observation 1: We can merge two sorted lists in linear time • What is in the input? • Both the lists, n = total amount of elements • Why is the complexity linear? • We must examine each element in each of the lists • Its linear in the total amount of elements • O(len(list1) + len(list2)) = O(n)

28. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3]

29. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3, 4]

30. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3,4,5]

31. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3,4,5,9]

32. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3,4,5,9,10]

33. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3,4,5,9,10,12]

34. Observation 1: We can merge two sorted lists in linear time [5,9,10, 100, 555] [3,4,12, 88, 535] [3,4,5,9,10,12, 88]

35. Observation 2 • Notice that merging two lists of length one ends up producing a sorted list of length two [5] [5] [5] [3] [3,5] [3,5] [3] [3] [3]

36. Lets build the intuition for Merge-Sort • We know we can merge sorted lists in linear time • We know that merging two lists of length one results in a sorted list of length two • Lets split our unsorted list into a bunch of lists of length one and merge them into progressively bigger lists! • We split a list into two smaller lists of equal parts • Keep splitting until we have lists of length one

37. Visual Representation log(n) n elements merged

38. Putting it all together • We know that there are log(n) splits • At each “level” we split each list in two • We know that we need to merge a total of n elements at each “level” • n * log(n) thus O(n log n)

39. Synopsis • Took a look at the code for bubble sort • We learned an efficient way to swap the contents of two variables (or list locations) • We built the intuition as to why we can sort faster than quadratic time • Introduced the concept of merge sort

40. Homework • Start working on Project 5 • Play around with the concepts presented in recitation as well as the pre lab • They will help both with the lab AND project 5 • Review the project 4 solution • Many of the same concepts will be used in project 5