Notes on the 2015 Exam

Transcription

1 Notes on the 2015 Exam The stuff inside borders is all that you needed to write. The rest is commentary. Please also read notes on previous years exams especially the 2005 set of notes. Note that up to 2008 each question was worth 20 marks (for a total exam mark out of 80). So the relative marks per piece of solution will be very different. Question 1 (a) statistics 6 marks This required a sentinel controlled loop. Marks as follows 2 for while loop and its set up; 2 for all aspects of min; 2 for average. int main() { double tot = 0;//NB initialisation int count = 0;//NB initialisation int n, min; cin >> n; min = n;//nb while (n!= -9999) { tot = tot + n; count++; if (n < min) min = n; cin >> n; cout << endl; cout << min << " " << tot / count << endl; return 0; (b) polygon perimeter 15 marks This requires a counter controlled loop and a bit of attention to detail. First note that a polygon is a shape made from a series of connected straight lines of possibly varying lengths. The question implied that the sides of the polygon were not equal since it asked you to read in (x,y) coordinates of the n vertices. There were very few marks (5 of the 15) for reading two points, computing the length of that side, then multiplying by n! (In the 1E3 exam, every part of question 1 will require a loop!! Anything less than a loop is just too easy!) You needed to treat the first vertex differently, to use the loop to read all but the first one, and to keep the first one in mind till the end to close off the polygon. In the code below I

2 have not shown the code for the distance function, and you did not need to use a distance function you could just do the sum in the main program. Marks 3 for the counter controlled loop; 3 for computing distances correctly; 3 for computing the running total; 3 for moving the vertices along (xa = xb;); 3 for remembering the last edge. I penalized people who read in n pairs of vertices i.e. got the user to reenter every vertex twice, rather than remembering the second vertex of the previous edge. int main() { int n; double x1, y1, xa, ya, xb, yb, perimeter, length; cout << "This program computes the total distance between n successive (x, y) vertices."; cout << "Please first enter n: "; cin >> n; perimeter = 0; cout << "Now enter vertex 1:"; cin >> x1 >> y1; xa = x1; ya = y1; for (int i=2; i<=n; i++) { cout << "Now enter vertex " << i << ":"; cin >> xb >> yb; length = distance(xa, ya, xb, yb); cout << length << endl; perimeter = perimeter + length; //move on xa = xb; ya = yb; //Now add the final edge length = distance(xa, ya, x1, y1); cout << length << endl; perimeter = perimeter + length; cout << "The perimeter of that polygon is " << perimeter << endl; return 0; Note that this problem could be solved well using arrays. You would read into two arrays, and x array and a y array, and then work through the arrays computing edge

3 lengths. But its important to remember that you can t declare an array to be of a size not known at compile time, so you can not say cin >> n; double xs[n]; double ys[n]; Instead you have to assume there will never be more than say 100 vertices, and declare the arrays to be double xs[100] and then only use n of the slots. (c) Perfect numbers up to marks Nested for loop. The outer one handles each integer 1 to 500. The inner one works through integers looking for divisors of the current n. Note that you were asked to print out perfect numbers. Imperfect numbers should have been ignored so either you cout << n; or you don t. Nothing else. int main() { int n,i,sum; for (n=1; n<500; n++) { //test if n is perfect sum=0; // sum of divisors so far for (i=1;i<n;i++) { if (n%i==0) //if i is a divisor of n sum = sum + i; // add it on //end of looking for divisors of n if (n == sum) cout << n << " "; //end of testing numbers cout << endl; return 0; The most common error was setting sum to 0 at the start, but it has to be reset for each of the n s that we are testing for perfectness, so inside the outer for loop. This question can be done much more elegantly using functions but you were not penalized for not Q1 does not require you to write functions. The functions would be isafactor, isperfect, sumoffactors. See Q1cFNS2015.cpp linked from webpage. Question 2 (a)(i) 7 marks 1 mark for the declaration; 2 for the if statement; 4 for some loop that achieved the required effect. See notes from int gcd (int n1, int n2) { int i; //make i be the smaller of the two numbers if (n1 < n2) i = n1; else i = n2;

4 while (!((n1%i == 0) && (n2%i == 0))) //while i does not divide evenly into both n1 and n2 i--; //now i divides into both n1 and n2 return i; This solution is a direct translation of the suggested brute force algorithm and is an improvement of the gcd_better function provided in the solution to Practical 10. It depends on the fact that 1 will divide into any two integers, so that the while loop will stop when i is 1 without us having to explicitly tell it to do so. The WHILE loop says as long as it is not the case that i divides evenly into both n1 and n2, decrement i. The not is coded as!. The && means AND. Decrement means take 1 away from as in i--. An alternative formulation of this would be while ((n1%i!= 0) (n2%i!= 0)) i--; or as long as i does not divide n1 OR i does not divide n2, decrement i.. That the above WHILE loop is equivalent to the program above is an example of De Morgan s Law, which you may have heard of DeMorgan says NOT (A AND B) is equivalent to (NOT A) OR (NOT B). Many of you understandably used a FOR loop. The problem then is that you need to jump out of the FOR loop when you find a common divisor, or at least remember the highest one that you found. Remember that there can be many common divisors of two integers (e.g. 2, 3, 4, 6, 8, 12, and 24 are divisors of both 48 and 120) and we only want the highest one. Let s look at some alternatives using FOR loops. Assuming that n1 is the smaller of the numbers, and using /* i divides both */ as pseudocode for (!((n1%i == 0) && (n2%i == 0)))): here are some alternative solutions for (i = n1, i <= 1, i--) if (/* i divides both */) return i; The return jumps right out of the loop and out of the gcd function. for (i = n1, i <= 1, i--) if (/* i divides both */) {gcd = i; i = 0;

5 This one gets out of the loop by immediately setting i to 0, so that the (i<=1) terminating condition is made true. This fiddling with FOR loop control variables is not considered clean living and should be used sparingly. for (i = 1, i > n1, i++) if (/* i divides both */) gcd = i; This one works the other way, from 1 up towards n1. Each time it finds a common divisor it sets gcd to be that number. When the loop terminates the last common divisor encountered, which will be the biggest of them, will be in the gcd variable and can be returned. But if you return gcd as soon as you find it, inside the loop, you will be returning the least common divisor (which will be 1 always!). This was a common mistake. (a)(ii) 6 marks 2 marks for the declaration, especially the &s; 2 for calling gcd properly; 2 for updating n and d but not trying to return them. void simplify_fraction (int& n, int& d) { int g = gcd (n,d); n = n / g; d = d / g; return; (a)(iii) 5 marks int main() { int numer, denom; cout << "Enter your fraction's top and bottom:"; cin >> numer >> denom; simplify_fraction (numer, denom); cout << "\nthe simplest form of your fraction is "; cout << numer << "/" << denom << "\n"; return 0; This is all about knowing that you call simplify_fraction like that, then use the updated values of numer and denom after. To understand this you need to understand the &s in the definition of simplify_fraction. (b) (i) isprime 3 marks bool isprime(int n);

6 (ii) printnstars 5 marks 2 marks for the declaration; 2 for the for loop; 1 for the endl AFTER the loop. void printnstars (int n) { for (int i=1; i<=n; i++) cout << "*"; cout << endl; (iii) main 7 marks 1 mark for the header; 2 for the for loop; 1 for the call to printnstars; 3 for the whole IF stmt. int main() { for (int i=1; i<=5; i++) cout << " "; cout << endl; //test each int to 50 ; print if prime... for (int i=1; i<=50; i++) { if (isprime (i)){ printnstars(i); //else do nothing return 0; Question 3 (Question 2 in 2011) This question is testing your ability to use functions. Therefore there were marks for designing, declaring, defining, and calling functions properly. (a) close_enough 5 marks A very small bit of code (you were given the fn declaration) for 5 marks, but you had to test the right thing the absolute difference between x and y has to be smaller than precision. The caller of the function provides the very small number (precision) against which to test, so you should not mention or anything like it. bool close_enough (double x, y, precision) { return (fabs(x-y) < precision);

7 Because it was so easy, 1 mark was lost for nasty solutions that said if (fabs(x-y) < precision) return true; else return false; (b) newtonsqrt 15 marks You already knew how Newton s method for square roots works. This question challenged you to vary it a little. The close_enough function of part (a) was designed to help. You had to keep track of the previous and the new approximation, called old_approx and approx below, and keep going till these were close to each other (i.e. till there is little room for improvement of the approximation). Getting old_approx and approx started off, and then keeping them in sync was the key bit. If you didn t correctly maintain 2 versions of the approximation, you lost up to 7 marks. You were expected to use a function for improving approximations (better_approx). 2 marks off if you didn t. A loop is essential, so 4 marks went for the while line. No need for a main program. If you do provide one, make sure you call newton_sqrt properly! See Q3b2015.cpp for a full program that uses this function. double newtonsqrt(double n, double init, double precision) { double old_approx = init; double approx = better_approx(old_approx, n); while (!(close_enough (old_approx, approx, precision))) { old_approx = approx; approx = better_approx (old_approx,n); return approx; double better_approx (double x, double n) { return (n/x + x)/2; What s wrong with this version of the loop? while (!(close_enough (old_approx, approx, precision))) { approx = better_approx (old_approx,n); old_approx = approx; I got quite a few like this. It will never loop more than once. Simplifying a bit (this is wrong!!!) while (!(x == y)) { y = f(x); x = y;

8 If the last line inside a loop says give x the same value as y and then the loop test says while x is not equal to y the loop is definitely going to terminate immediately. For the same reason, you can t start old_approx and approx off as init they need to be different from one another. (c) Newton for f 13 marks The intention was that you would use the close_enough provided by 2(a), and the same loop structure as 2(b). But this was rarely done. You were expected to use functions for f, Df, and better_approx. In this case there is no n, so the Newton function, and better_approx don t have a parameter n. Otherwise, it s exactly like 2(b). Some people decided not to use any loop because I didn t specify how precise the approximation had to be. They lost marks, but these are not the people who failed! double newtonf(double init, double precision) { double old_approx = init; double approx = better_approx(old_approx); while (!(close_enough (old_approx, approx, precision))) { old_approx = approx; approx = better_approx (old_approx); return approx; double better_approx (double x) { return x - (f(x) / Df(x)); //close_enough as in 2(a). //The specific function and its derivative function double f (double x) {return x*x*x + 5*x - 3; double Df (double x) {return 3*x*x + 5; Question 4 This question required you to complete a program to index text that has been read into an array. We talked about this program in class.

9 (a) 3 marks The keyword const in this context says that the function will not / cannot alter the value of the array passed in as a or nums. It keeps the array values safe and tells the user of the function that an array passed in will not be affected. A function can normally alter the values of an array parameter a normal array parameter behaves like a call-by-reference parameter. To avoid that, you need to explicitly protect it using the const keyword. Your answer to this had to make clear that you understood that the const applied to an array, and to what the function could do. This const is not the same as the one used to declare constant values such as const double PI = (b) 7 marks int count (string s, const string a[], int size) { int n = 0; for (int i = 0; i < size; i++) if (a[i] == s) n++; return n; This didn t cause much difficulty. For each element of the array, using the parameter size to tell you how many elements there are, if the array entry is equal to the thing we are counting (the string s), add one to the counter. And start at 0! And return the counter. (c) 8 marks int maxpos (const int nums[], int size) { int i; int maxi=0;//slot of max so far is 0 for (i=1; i<size; i++) //start at 1 if (nums[i] > nums[maxi]) maxi = i; return maxi; This was a little trickier. You needed to distinguish between the biggest value seen so far, nums[maxi], and the slot containing the biggest value,

10 maxi. You need to return maxi, but you need to be comparing nums[maxi] against the current array entry, nums[i]. You might find it easier to store the biggest value seen so far at the same time as you update maxi: int maxi=0;//slot of max so far is 0 int maxvalue = nums[0]; for (i=1; i<size; i++) //start at 1 if (nums[i] > maxvalue) { maxi = i; maxvalue = nums[i]; return maxi; It s a queston of not comaring apples with oranges, not putting apples into containers for oranges! i and maxi are indexes into the array, and the function has to return one of these things. maxvalue and nums[i] are values in the array, and the function has to find (but not return) the biggest of these. (d) 15 marks int counts [NUMTERMS];//holds a count for each terms in terms int i; //no need to initialize the counts, as the next for loop assigns some //value to every slot of the array. But no harm to initialize either. //count index terms for (i=0; i< NUMTERMS; i++) counts[i] = count (terms[i], text, numwords); //output counts for (i=0; i< NUMTERMS; i++) if (counts[i] > 2) { cout << setw(15) << left << terms[i]; cout << setw(4) << right << counts[i] << endl; //determine most common term int max = maxpos (counts, NUMTERMS); string topterm = terms[max];

11 This wasn t much code for 15 marks. But you needed to pay attention. The array needed here is for storing counters for each term we want to count, i.e. each term in the terms array it is declared as string terms [NUMTERMS]. So we need NUMTERMS counters. (2 marks for the array declaration). Then we need to arrange to use the count function to get the appropriate counter and store it in the counts array the count of terms[i] term goes in the counts[i] slot. (3 marks for that for loop). To call count, pay attention to what each parameter is the first one is a string in this case a term from the terms array. The second parameter is where we want to look for the string, our text. And the final parameter is the number of words in that text, that is the value assigned to numwords by the call to readtosentinel at the top fo the program note the & beside the third parameter of readtosentinel s declaration. Then we need to print out the terms and their counters easy enough (4 mark). Finally, and many of you missed this, we need to USE THE maxpos FUNCTION to find the position of the largest counter, and then get the corresponding term stored in topterm, ready for the last line of the program (not shown above). (4 marks, you missed 2 if you didn t use the maxpos function!) Other Miscellaneous Comments that I noted while grading in They are all very useful to you if you are repeating 1E3: Sentinel Controlled Loops Template is cin >> x; while (x!= ) { *** cin > x; Where the *** are you put all processing of the current valid x. The processing of x must all be inside the loop. I had many examples of cin >> x;

12 while (x!= ) { cin > x; tot = tot+x; //wrong more stuff on x.//wrong But those last two lines must be inside the loop, before the cin > x statement. Obviously instead of x, you might have studentno or code or n or whatever it is that you are reading that will eventually be the sentinel instead of a valid value. Many people used the above template (with ***s in it or in it!!!!) every time they thought a while loop was needed. The template is ONLY for SENTINEL CONTROLLED input. Functions Many of these comments or similar appear in Notes for 2005 exam. Local variables and accessing a function s value: If a function looks like this int f(int x) { int ans; ans = x; return ans; you can t do this z = 4; f(z); cout << ans; // wrong ans here is not related to f s ans and expect it to print the value of f(z) ans only has meaning inside f. Even if you declared ans in the calling program, that would be a separate variable from the one f uses, which is a local variable whose scope in the function f. The calling program has no access to f s ans. The correct way to call f and use the value it returns is: or cout << f(z); int x = f(z); //now use or print x

13 Accessing parameters: With the following declaration of f int f(int x, int y) the body of f has access to variables called x and y, and the values in there are the ones provided by the calling function. Therefore, f should not redeclare these variables read values for these variable initialize these variables So more than likely these are all wrong: int f(int x, int y) { int x, y; //creates new local variables x and y which //effectively hides the ones passed in as parameters int f(int x, int y) { cin >> x >> y; //if it succeeds in reading data it will replace // the values the calling function provided. int f(int x, int y) { y=0; //if the calling function provides f with a value for y //f should use it!! Not replace it. And, unrelated to parameters, but the f declared above should not print any values, but must return its answer. So NOT int f(int x, int y) { cout << (x*y)/2; return 0; but probably something like int f(int x, int y) { return (x*y)/2; Good luck!