Week 12 - Friday

 What did we talk about last time?  Finished hunters and prey  Class variables  Constants  Class constants  Started Big Oh notation

 Here is a table of several different complexity measures, in ascending order, with their functions evaluated at n = 100 DescriptionBig Ohf(100) ConstantO(1)1 LogarithmicO(log n)6.64 LinearO(n)O(n)100 LinearithmicO(n log n) QuadraticO(n2)O(n2)10000 CubicO(n3)O(n3) ExponentialO(2 n )1.27 x FactorialO(n!)9.33 x

 Computers get faster, but not in unlimited ways  If computers get 10 times faster, here is how much a problem from each class could grow and still be solvable DescriptionBig OhIncrease in Size ConstantO(1)Unlimited LogarithmicO(log n)1000 LinearO(n)O(n)10 LinearithmicO(n log n)10 QuadraticO(n2)O(n2)3-4 CubicO(n3)O(n3)2-3 ExponentialO(2 n )Hardly changes FactorialO(n!)Hardly changes

 There is nothing better than constant time  Logarithmic time means that the problem can become much larger and only take a little longer  Linear time means that time grows with the problem  Linearithmic time is just a little worse than linear  Quadratic time means that expanding the problem size significantly could make it impractical  Cubic time is about the reasonable maximum if we expect the problem to grow  Exponential and factorial time mean that we cannot solve anything but the most trivial problem instances

 Memory usage can be a problem  If you run out of memory, your program can crash  Memory usage can have serious performance consequences too

 Remember, there are multiple levels of memory on a computer  Each next level is on the order of 500 times larger and 500 times slower Cache Actually on the CPU Fast and expensive RAM Primary memory for a desktop computer Pretty fast and relatively expensive Hard Drive Secondary memory for a desktop computer Slow and cheap 1000X SizeSpeed

 If you can do a lot of number crunching without leaving cache, that will be very fast  If you have to fetch data from RAM, that will slow things down  If you have to read and write data to the hard drive (unavoidable with large pieces of data like digital movies), you will slow things down a lot

 Memory can be easier to estimate than running time  Depending on your input, you will allocate a certain number of objects, arrays, and primitive data types  It is possible to count the storage for each item allocated  Remember that a reference to an object or an array costs an additional 4 bytes on top of the size of the object

 Here are the sizes of various types in Java  Note that the N refers to the number of elements in the array or String TypeBytes boolean 1 char 2 int 4 double 8 TypeBytes boolean[] 16 + N char[] N int[] N double[] N TypeBytes reference4 String N object8 + size of members array of objects16 + (4 + size of members)N

 Lets say that I give you a list of numbers, and I ask you, “Is 37 on this list?”  As a human, you have no problem answering this question, as long as the list is reasonably short  What if the list is an array, and I want you to write a Java program to find some number?

 Easy!  We just look through every element in the array until we find it or run out  If we find it, we return the index, otherwise we return -1 public static int find( int[] array, int number ) { for( int i = 0; i < array.length; i++ ) if( array[i] == number ) return i; return -1; } public static int find( int[] array, int number ) { for( int i = 0; i < array.length; i++ ) if( array[i] == number ) return i; return -1; }

 Unfortunately for you, we know about Big Oh notation  Now we have some way to measure how long this algorithm takes  How long, if n is the length of the array?  O(n) time because we have to look through every element in the array, in the worst case

 Is there any way to go smaller than O(n)?  What complexity classes even exist that are smaller than O(n)?  O(1)  O(log n)  Well, on average, we only need to check half the numbers, that’s ½ n which is still O(n)  Darn…

 We can do better with more information  For example, if the list is sorted, then we can use that information somehow  How?  We can play a High-Low game

 Repeatedly divide the search space in half  We’re looking for 37, let’s say Check the middle (Too high) Check the middle (Too low) Check the middle (Too low) Check the middle (Found it!) 37

 How long can it take?  What if you never find what you’re looking for?  Well, then, you’ve narrowed it down to a single spot in the array that doesn’t have what you want  And what’s the maximum amount of time that could have taken?

 We can apply this idea to a guessing game  First we tell the computer that we are going to pick a number between 1 and n  We pick, and it tries to narrow down the number  It should only take log n tries  Remember log 2 (1,000,000) is only about 20

 This is a classic interview question asked by Microsoft, Amazon, and similar companies  Imagine that you have 9 red balls  One of them is just slightly heavier than the others, but so slightly that you can’t feel it  You have a very accurate two pan balance you can use to compare balls  Find the heaviest ball in the smallest number of weighings

 It’s got to be 8 or fewer  We could easily test one ball against every other ball  There must be some cleverer way to divide them up  Something that is related somehow to binary search

 We can divide the balls in half each time  If those all balance, it must be the one we left out to begin with

 How?  They key is that you can actually cut the number of balls into three parts each time  We weigh 3 against 3, if they balance, then we know the 3 left out have the heavy ball  When it’s down to 3, weigh 1 against 1, again knowing that it’s the one left out that’s heavy if they balance

 The cool thing is…  Yes, this is “cool” in the CS sense, not in the real sense  Anyway, the cool thing is that we are trisecting the search space each time  This means that it takes log 3 n weighings to find the heaviest ball  We could do 27 balls in 3 weighings, 81 balls in 4 weighings, etc.

 Sorting

 Finish Project 4  Due tonight before midnight!