CSC-140 Assignment 4

Transcription

1 CSC-140 Assignment 4 Please do not Google a solution to these problem, cause that won t teach you anything about programming - the only way to get good at it, and understand it, is to do it! 1 Introduction This assignment deals with 3 major topics. Method invocation (writing your own methods), using static fields (think of these as global variables that all methods can see and use), and recursive methods (method calling itself.) 1.1 Recursive Exponential Function Remember you wrote a for loop to compute x y. We will start by implementing that same method again, but in a recursive fashion. Consider the following definition of the exponential function - let us call it f: { 1 if x = 0 f(x, y) = x f(x, y 1) otherwise With this definition, we can implement a Java method f with the following header: public static int f ( int x, int y ) { // do what f does above. Question 1: Implement this function, and test it with a few calls to make sure it works correctly. What happens if you give it a negative value for y? Would it also work if you changed the value of x and the return type to double? 1

2 1.2 Fibonacci Numbers Next, let us look at the well known Fibonacci number sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,... This is a sequence that comes up all over many different branches of science. It is used in biology as well as math; most famously perhaps it relates to the golden ratio (φ) in the way that the limit of the ratio of two consecutive Fibonacci numbers approaches the golden ratio. Let us formally define the n th Fibonacci number as follows: 0 if n = 0; F ib(n) = 1 if n = 1; F ib(n 1) + F ib(n 2) otherwise We see that F ib(2) can be calculated by calculating F ib(1) and F ib(0) and then adding them together: or F ib(2) = F ib(1) + F ib(0) = = 1 F ib(3) = F ib(2) + F ib(1) = F ib(2) + 1 = F ib(1) + F ib(0) + 1 = = 2 Question 2: Using recursion, and the following Java method header, implement a Java method that can calculate the n th Fibonacci number (remember, the 0 th number is 0): public static long f i b ( int n) { // your code here (We use long variables, because the result gets big fast!) If we want to count the number of additions in the fib method, we can add a global variable that can be accessed both from the fib method and from the main method. Let us add such a global variable (in reality called a static field ), by placing the following declaration above (or below; where doesn t matter as long as it is not inside a method) the fib method: 2

3 public static int f i b c o u n t = 0 ; We initialize it to 0, but if we call fib more than once in the main method, you must remember to reset it back to 0; naturally, this is because it is global and only gets initialized once, namely when the entire program starts, so be careful about using such variables. We can increment this counter every time we do an addition in the fib code, and then print it out in the main method. Question 3: Add this to your code and check that it works. Here are a few examples from my code for you to check your output against: fib(1) = 1 and took 0 additions to compute. fib(2) = 1 and took 1 additions to compute. fib(10) = 55 and took 88 additions to compute. fib(25) = and took additions to compute. Question 4: Can your code compute f ib(100), or f ib(1000)? My guess is that you probably get tired of waiting at best. f ib(100) = Recursion is simple, and easy, but not always the fastest way of doing things; the main reason as you can see is the sheer amount of additions it takes to compute a large Fibonacci number. With the recursion in the method you implemented, we work our way backwards in the sequence, but if you were to compute it by hand you would work your way forwards. You would start by adding 0 and 1 and get 1, then add 1 and 1 and get 2, then add 1 and 2 and get 3, then add 2 and 3 and get 5 and so on. This looks very much like a for loop, and it can indeed be implemented much more efficiently with a for loop. Question 5: Implement f ibf ast with the following header: public static void f a s t F i b ( int n) { // your code here that uses a for loop and some if statements (you may not call any other 3

4 methods) to compute the same numbers as fib. Test your code and shows that it works. Can you compute fibf ast(100)? Add a new counter to your code to count the number of additions for fibf ast. What would the count be for fibf ast(1000)? (I don t think you can calculate that number, it is way too big to fit in a long variable it has 209 digits and is 26,863,810,024,485,359,386,146,727,202,142,923,967,616,609,318,986,952,340, 123,175,997,617,981,700,247,881,689,338,369,654,483,356,564,191,827,856, 161,443,356,312,976,673,642,210,350,324,634,850,410,377,680,367,334,151, 172,899,169,723,197,082,763,985,615,764,450,078,474,174,626 ;-) Recall the definition of the golden ration (φ): fib(n) φ = lim n > fib(n 1) Naturally, we cannot compute an infinite limit like that, but we can approximate it; the best value we can get to is One approach is to write a do loop that keeps running until the difference between two consecutive approximations of φ is less than some small number ɛ, that is: fib(i) fib(i 1) fib(i 1) fib(i 2) < ɛ When comparing such small differences, it is always a good idea to use absolute values ( ). You can calculate the absolute value of a number by using Math.abs(). Question 6: Implement a method called goldenratio that takes in a and returns a double, and has a do loop that calculates an estimate of φ, try with different ɛ values. Also try with ɛ = How many iterations did that take? (mine took 43) Remember, to be able to compute fib(n 2) you need to start your counter a at least 2. Remember a long divided by a long is a long, so make sure you convert your longs to doubles before dividing. Also, use fastfib rather than fib. 4

5 1.3 Towers of Hanoi Remember this game: The objective is to move all the discs from peg 1 to peg 3 using peg 2. The rules are simple: You cannot place a larger disc on top of a smaller one. The puzzle was invented by the French mathematician douard Lucas in There is a legend about an Indian temple which contains a large room with three time-worn posts in it surrounded by 64 golden disks. Brahmin priests, acting out the command of an ancient prophecy, have been moving these disks, in accordance with the rules of the puzzle, since that time. (from Wikipedia; its ok for me to quote Wikipedia in an assignment, but you cannot ever do so in a serious publication!) You are to write a Java method called move that produces the following output (here run with just 4 discs): Move a disk from peg 3 to peg 2 5

6 Move a disk from peg 2 to peg 1 This might seem like a complicated piece of code, but using recursion, it is super simple. Consider how we can break the task into smaller tasks (we call that divide-and-conquer). To move 4 discs from peg 1 to peg 3 we can do the following: 1. Move 3 discs from peg 1 to peg 2 (via peg 3 if necessary). 2. Move 1 disc from peg 1 to peg Move 3 discs on peg 2 to peg 3 (via peg 1 if necessary). A recursive procedure must always be able to solve some of the problems directly without calling itself again, we call that the base case. For the exponential function, the base case was when y = 0, and we knew the result to be 1. For the Towers of Hanoi, the base case is when we have to move just one disc. We can do that directly by moving it from the peg on which it is, onto the peg to which it is going. Another important thing about recursion is that you should always call the recursive procedure with a smaller problem than what you are trying to solve; else the recursion never ends! Look at the 3 steps above. The middle one is the base case and the two others are recursive calls (they solve a simpler/smaller problem). We can use the following Java header: public static void move( int n, int from, int to, int via ) { i f (n == 1) // p r i n t out the move else // your code f o r the r e c u r s i v e c a l l here and it can be called as follows (to move the 4 discs from peg 1 to peg 3 via peg 2): move(4, 1, 3, 2). Look at the output again: 6

7 Move a disk from peg 3 to peg 2 <---- Move a disk from peg 2 to peg 1 The arrow point to the move of the largest disc directly from peg 1 to peg 3; the output before and after represent the output of the two recursive calls. Also note, if you made the original call with 3 discs: move(3, 1, 2, 3), that is, move 3 discs from peg 1 to peg 2 via peg 3, you would get the output you see before the arrow. The output after the arrow corresponds to the call move(3, 2, 3, 1). Cool, huh? Hint, the recursive case will have 3 calls; one to move n 1, then 1 and then n 1 again. Question 7: Implement the move method. An alternative implementation is as follows: do nothing if n = 0, but the middle case in the else part of that if statement does the printing. This solution is a little more efficient. Question 8: Test your code with different values to make sure it works. What is the maximum number your code works for? (The answer here probably depends on how much patience you have) 7

8 Question 9: Now, add another counter to your class. Remember to initialize it to 0 every time you call move (from the main method - not from within the move method itself!) Increment this counter every time you print a move, and after the call to move (from main) print out the number of moves made. If the monks can move one disc a second, how many years does it take to move all 64 discs? You can t run your code, cause you don t have that much time to wait, but if you look at it you probably come up with the following idea: to move n discs I have to move n 1 twice plus the one at the bottom, so if we make a function to count we get: T C(n) = 2 T C(n 1) + 1; Question 10: Implement a recursive Java method towercount that has the following header: public static long towercount ( int n) { // your code here Use this method to produce the following output: Moving 3 towers takes 7; that would take 0 years. Moving 4 towers takes 15; that would take 0 years. Moving 5 towers takes 31; that would take 0 years. Moving 6 towers takes 63; that would take 0 years. Moving 7 towers takes 127; that would take 0 years. Moving 8 towers takes 255; that would take 0 years. Moving 9 towers takes 511; that would take 0 years. Moving 10 towers takes 1023; that would take 0 years. Moving 11 towers takes 2047; that would take 0 years. Moving 12 towers takes 4095; that would take 0 years. Moving 13 towers takes 8191; that would take 0 years. Moving 14 towers takes 16383; that would take 0 years. Moving 15 towers takes 32767; that would take 0 years. Moving 16 towers takes 65535; that would take 0 years. Moving 17 towers takes ; that would take 0 years. Moving 18 towers takes ; that would take 0 years. Moving 19 towers takes ; that would take 0 years. Moving 20 towers takes ; that would take 0 years. 8

9 Moving 21 towers takes ; that would take 0 years. Moving 22 towers takes ; that would take 0 years. Moving 23 towers takes ; that would take 0 years. Moving 24 towers takes ; that would take 0 years. Moving 25 towers takes ; that would take 1 years. Moving 26 towers takes ; that would take 2 years. Moving 27 towers takes ; that would take 4 years.... Moving 63 towers takes... Moving 64 towers takes... the... represent output that I have redacted. I want you to compute the right value. Remember a year is 60*60*24*365 seconds. Question 11: What value do you get for 63? What about 64? Explain! (You ll see what I mean when you see the output!) 1.4 Fibonacci - Again! You probably realized that your fib code is much nicer than than your fastf ib code. Take a look at this implementation: public static long t a i l F i b ( int n, long acc1, long acc2 ) { i f (n == 0) return acc1 ; else i f (n == 1) return acc2 ; else { return t a i l F i b (n 1, acc2, acc1 + acc2 ) ; A call to fib with the value n is the same as a call to tailf ib with the values n, 0 and 1. So fib(n) = tailf ib(n, 0, 1). Question 12: Type the code in and try it. Explain how it works and related it to your own fastf ib code. 9

10 2 Topics Covered Methods. Recursion. Static fields (global variables.) 3 Work List 1. Make sure you read the Topics Covered section and familiarize yourself with all the topics. 2. Create a file Assignment4.java, and implement the code from the questions above. 3. Test your program with a number of different values. 4. Once you are happy with your solution, go to csgfms.cs.unlv.edu and hand it in. Just the.java file! 5. Bring to class (along with the printout of your solution) a write up in which you explain how you solved the problem, and show output from a couple of tests; enough to convince me that it works. 4 Due Date The Assignment4.java file must be uploaded to csgfms.cs.unlv.edu no later than Monday March 7th before midnight (midnight between Monday and Tuesday), and the write up should be brought to class the day after. 10

11 5 Sample Output from my Solution QUESTION 1: f(3,4) = 81 f(2,0) = 1 f(2,25) = QUESTION 2 & 3: fib(1) = 1 and took 0 additions to compute. fib(2) = 1 and took 1 additions to compute. fib(10) = 55 and took 88 additions to compute. fib(25) = and took additions to compute. QUESTION 5: fastfib(100) = and took 99 additions to compute. QUESTION 6: It took 43 iterations to compute phi, which is QUESTION 7 & 9: Move a disk from peg 3 to peg 2 Move a disk from peg 2 to peg 1 It took 15 moves for 4 discs. 11

12 Move a disk from peg 3 to peg 2... It took 1023 moves for 10 discs. QUESTION 10: Moving 3 towers takes 7 moves; that would take 0 years. Moving 4 towers takes 15 moves; that would take 0 years. Moving 5 towers takes 31 moves; that would take 0 years. Moving 6 towers takes 63 moves; that would take 0 years. Moving 7 towers takes 127 moves; that would take 0 years. Moving 8 towers takes 255 moves; that would take 0 years. Moving 9 towers takes 511 moves; that would take 0 years.... Moving 63 towers takes... Moving 64 towers takes... QUESTION 11: tailfib(0,0,1) = 0 tailfib(1,0,1) = 1 tailfib(2,0,1) = 1 tailfib(10,0,1) = 55 tailfib(100,0,1) = Again, the output in questions 7, 9, and 10 have been shortened a little (else this handout would be 30 pages long!) 12