CS 135 Lab Assignments Week 12

Transcription

1 CS 135 Lab Assignments Week 12 Professor: Matt B. Pedersen This handout is the assignment that you must finish for the lab portion of the course in week 12. You must finish the assignments yourself; if you need any help ask the TA or the professor. You may not work together with other students in solving the assignments. The weekly assignments must be handed in on a piece of paper, typed neatly (spell checked etc.) and look nice. The assignments are due in the the professor s mailbox labeled Matt Pedersen in TBE-A211 the following Wednesday before the computer science office closes at 5PM. All lab assignments must be handed in if you wish to attend the final exam. Late assignments are not accepted for any reason except sickness or family emergencies, and the former requires a doctor s notice. 1 Introduction For this week we are going to write a number of different implementations of the same algorithm, namely the algorithm that computes binomial coefficients. 2 Regular Vanilla Factorial Using the factorial implementation from last week and the binomial coefficient function, also from last week, determine the largest value of n where all ( n m) are calculated correctly. In addition, add an extra parameter c which counts the number of additions and multiplications performed to compute the result. This parameter should be passed-by-reference, that is, the type should be int&. 1

2 3 Prime Factor Reduction Consider the following approach. Instead of simply calculating the numerator (n!) and the denominator (m!(n-m)!) and then performing the division, we can define two variables: numerator and denominator, both initialized to 1, and then enter into a loop that loops through the range n,n-1,n-2,...,m+1 for the numerator and n-m,...,3,2 for the denominator. Of course there is no guarantee that the set of terms for the numerator and the denominator are of equal size, but that can be guarded by if statements: numerator = 1; denominator = 1; numerator_start = n; numerator_end = m+1; denominator_start = n-m; denominator_end = 2; while (numerator_start >= numerator_end denominator_start >= denominator_end) { if (numerator_start >= numerator_end) { numerator = numerator * numerator_start; numerator_start--; if (denominator_start >= denominator_end) { // do something funky here denominator_start--; return numerator/denominator; Writing // so something funky here as this: if (numerator % denominator_start == 0) numerator = numerator / denominator_start; else denominator = denominator * denominator_start; might make it possible to compute one or two higher ns but there is a better way: if denominator start does not divide numerator, then we can loop 2

3 through all the prime factors of denominator start and for each one if divides numerator, perform the division, and if it doesn t simply multiply it to denominator, just like we did in the code above. // do something funky here: long denom = denominator_start; long m = 2; while (denom > 1) { // something here if m divides denom and it also divides numerator, do so! if it divides denom but not numerator multiply it onto denominator; either way, loop again without changing m (as there could be multiple factors of m). If m does not divide denom, then just increase m. Example: n = 7, m = 3: C(n, m) = C(7, 3) = num goes through 7,6,5,4 den goes through 4,3,2,1 ( ) 7 = 3 7! 3!(7 3)! = numerator denominator num den = 2* = 2*2 7 2* * = *2* = *5* = 35 3

4 In line 2, the den=4 consists of two prime factors, namely 2 and 2 - since neither of them divide 7, they both get multiplied onto denominator. I have underlined the two different prime factors. Implement this algorithm, and like in the previous version, add a reference parameter that also counts the number of of multiplications, additions and divisions. 4 Recursive Version This problem lends itself to a recursive solution. Using the following recursive equation it should be easy to implement a recursive version: ( ) { n 1 if m == 0 or m == n = ( n 1 ) ( m m + n 1 ) m 1 otherwise Implement a recursive version using the formula above, and add a reference parameter to count the number of additions and multiplications. 5 Recursive Version with Look up Table As you will have noticed, the recursive version is slow! Really slow - I gave up waiting for it. The problem is that there are so many recursive calls with the same value; a simple solution is to create a look up table and once we have computed a value, put it into the table, that way we never have to re-compute it again. Like with one dimensional arrays we cannot pass two-dimensional arrays without dimensions. I suggest defining a constant called SIZE of size 100, and the take in a two-dimensional array lookup[size][size], which should be initialized with 0. Remember, though C++ uses call-by-value, arrays are passed by reference, so changes made in the function will be made in the actual parameter as well. If the function is called with n and m and lookup[n][m] is not 0, then the value has already been computed, and you can return it; if it is 0, then you need to compute it like above and once you have the result, put it into lookup[n][m]. 4

5 6 Iterative Version with Look up Table Rather than using recursion, if the entry lookup[n][m] is 0, compute the entire table starting in a double for loop and then simply return lookup[n][m]. Actually we do not need to compute the entire look array, but only the entries [i][j] where j i. Naturally the amount of work in terms of number of additions will depend on the size of the table, but the amount of work is constant. Implement this version; also add a reference variable to count the number of additions. 7 Amount of Work For each of your solutions specify the amount of work required to compute ( 20 10). For those where you can, specify the amount of work it takes to compute ( 40 20). 8 Benford s Law If you got your last two implementations right, the maximum n for which they compute the correct values should be 66. Make a copy of one of the these versions in a new file. Add a function called leadingdigit that takes in a long number and returns the leading digit of the number. For example, for , the leading digit is 7. Benford s Law, also called the First-Digit Law, refers to the frequency distribution of digits in many (but not all) real-life sources of data. In this distribution, the number 1 occurs as the leading digit about 30% of the time, while larger numbers occur in that position less frequently: 9 as the first digit less than 5% of the time. Benford s Law also concerns the expected distribution for digits beyond the first, which approach a uniform distribution. This result has been found to apply to a wide variety of data sets, including electricity bills, street addresses, stock prices, population numbers, death rates, lengths of rivers, physical and mathematical constants, and processes 5

6 described by power laws (which are very common in nature). It tends to be most accurate when values are distributed across multiple orders of magnitude. The probability of the leading digit being d is defined as P (d) = log 10 (d + 1) log 10 (d) = log 10 (1 + 1 d ) Implement some code that uses a one dimensional array of size 10 (use indices 1 through 9, and ignore 0) to count the number of different leading digits if the binomial coefficients ( ) n, m for n {1, 2, 3,..., 66. Output the following for each digit d: 1,2,3,4,5,6,7,8,9: 1. The number of binomial coefficients starting with the digit d, 2. The actual percentage counted as well as the value P (d) as defined above. 3. A string of a *s, where a is the integer value of the actual percentage counted. Here is my output: 1 (738) [30.10] ******************************** 2 (378) [17.61] **************** 3 (284) [12.49] ************ 4 (222) 9.75 [ 9.69] ********* 5 (179) 7.86 [ 7.92] ******* 6 (158) 6.94 [ 6.69] ****** 7 (124) 5.44 [ 5.80] ***** 8 (105) 4.61 [ 5.12] **** 9 ( 90) 3.95 [ 4.58] *** 6